How to format linguistic example lists?

[dj1121]

Hi all,

I am a linguist, and I would like to use Typst to make linguistic example lists. An example is just a 3-tuple with sentence, gloss, and translation values. Often, it can also just be a single “sentence” value if it’s English. Printing this via a grid is simple enough:

In linguistics papers, these sorts of examples can be arbitrarily nested. For example, we could refer to examples below as 1a), 2b.i), 3), etc.

1) a.  [SENTENCE]
       [GLOSS]
       [TRANSLATION]
   b. ...
   c. ...

2) a. ...
   b.
       i. [SENTENCE]
          [GLOSS]
          [TRANSLATION]
       ii. ... 
       iii. ...

3) [SENTENCE]
   [GLOSS]
   [TRANSLATION]

As you might expect, I don’t want to type these out manually every time I write an example. I want to make a function that can print the formatting from an arbitrarily nested list of examples, like the list below:

#let xlist = (
// Top-level "1)" 
 (
     // 1a
      (sentence: [this is sentence],
      gloss: [This is the gloss],
      tran: [this is tran]
      )

   // 1b
      (sentence: [this is sentence],
      gloss: [This is the gloss],
      tran: [this is tran]
     )

),
// Top-level "2)"
( 
  // 2a
  (sentence: [this is sentence],
   gloss: [this is gloss],
   tran: [this is tran],
   )
)

I figured this could be accomplished with grid(), but I am lost on how to dynamically allocate grids. I thought about looping over the examples, nesting grid() calls, but I quickly became stuck. I know that each level of the list should have 2 columns (one for label, one for content). Then, the number of rows should depend on how what’s inside the current level of the list.

// Pass in list of examples
#let ex(examples) = {
  
  grid(
      columns: 2, // two top main cols
      rows: examples.len(), // number of top-levels (i.e., 1, 2, 3)
      column-gutter: 1em,
      row-gutter: 1em,

      for example in examples {

            // ??
         
        }        
  )

I’m having the feeling it might be good to use a recursive solution, but I am new to Typst, and thought I should ask for some guidance before I go too far in that direction. Does anyone have guidance as to how to make such a function, or if another solution would be better? Any help would be much appreciated! Thank you.

[quachpas]

Something like this maybe? Credits goes to @Eric for to-enum.

enum and list need to be built recursively with the previous input, hence we use array.fold, otherwise numbers won’t follow.

I have split the formatting and display into separate functions, but it’s honestly possible to just merge both.

The numbering is set to using a set rule: set enum(numbering: "1.a.i)").

@dj1121

For example, we could refer to examples below as 1a), 2b.i), 3), etc.

As for referencing an enum.item, that’s still work in progress. Maybe, that’s better answered in another topic. It is absolutely doable, with a mix of metadata and a custom ref system.

Summary

#let xlist = (
  (
    // 1a
    (
      sentence: [this is sentence 1 (1a)],
      gloss: [This is the gloss],
      tran: [this is tran],
    ),
    // 1b
    (
      sentence: [this is sentence 2 (1b)],
      gloss: [This is the gloss],
      tran: [this is tran],
    ),
  ),
  (
    // 2a
    (
      sentence: [this is sentence 3 (2a)],
      gloss: [this is gloss],
      tran: [this is tran],
    )
  ),
  (
    (
      (
        // 3a i
        sentence: [this is sentence (3a i)],
        gloss: [this is gloss],
        tran: [this is tran],
      ),
      (
        // 3a ii
        sentence: [this is sentence (3a ii)],
        gloss: [this is gloss],
        tran: [this is tran],
      ),
    ),
  ),
)
#let format(xlist, level: 0) = {
  // set enum(numbering: "1.a.i)")
  if type(xlist) == dictionary {
    xlist.values().map(smallcaps).join("\n")
  } else if type(xlist) == array {
    for example in xlist {
      let body = format(example, level: level + 1)
      (body,)
    }
  }
}
#let to-enum(arr) = {
  set enum(numbering: "1.a.i)")
  arr
    .fold(
      (),
      (items, curr) => {
        // If the current entry is an array, append a new subenum to
        // the last item. Otherwise, create a new enum item.
        if type(curr) == array { items += (to-enum(curr),) } else {
          items.push(curr)
        }
        items
      },
    )
    .map(enum.item)
    .join()
}

#to-enum(format(xlist))

[Andrew]

Here you go (-12 lines):

#let format(xlist, level: 0) = {
  if type(xlist) == dictionary {
    xlist.values().map(smallcaps).join("\n")
  } else if type(xlist) == array {
    xlist.map(example => (format(example, level: level + 1),)).join()
  }
}

#let to-enum(arr) = {
  set enum(numbering: "1.a.i)")
  let fold-func = (items, curr) => {
    // If the current entry is an array, append a new subenum to
    // the last item. Otherwise, create a new enum item.
    items + (if type(curr) == array { to-enum(curr) } else { curr },)
  }
  arr.fold((), fold-func).map(enum.item).join()
}

Full example

#let format(xlist, level: 0) = {
  if type(xlist) == dictionary {
    xlist.values().map(smallcaps).join("\n")
  } else if type(xlist) == array {
    xlist.map(example => (format(example, level: level + 1),)).join()
  }
}

#let to-enum(arr) = {
  set enum(numbering: "1.a.i)")
  let fold-func = (items, curr) => {
    // If the current entry is an array, append a new subenum to
    // the last item. Otherwise, create a new enum item.
    items + (if type(curr) == array { to-enum(curr) } else { curr },)
  }
  arr.fold((), fold-func).map(enum.item).join()
}

#let xlist = (
  (
    // Top-level "1)"
    (
      // 1a
      sentence: [Der Hund bellt.],
      gloss: [DEF.MASC.SG.NOM Hund bell-3SG.PRES],
      tran: [The dog barks.],
    ),
    (
      // 1b
      sentence: [Die Katze schläft.],
      gloss: [DEF.FEM.SG.NOM Katze schlaf-3SG.PRES],
      tran: [The cat sleeps.],
    ),
  ),
  (
    // Top-level "2)"
    (
      // 2a
      sentence: [Wir gehen ins Kino.],
      gloss: [1PL.NOM geh-1PL.PRES in+das.ACC Kino],
      tran: [We are going to the cinema.],
    )
  ),
  (
    // Top-level "3)"
    (
      // 3a
      (
        // 3a i
        sentence: [Ich habe ein Buch gelesen.],
        gloss: [1SG.NOM hab-1SG.PRES ein.ACC Buch les-PART.PST],
        tran: [I have read a book.],
      ),
      (
        // 3a ii
        sentence: [Sie wird morgen ankommen.],
        gloss: [3SG.FEM.NOM werd-3SG.PRES morgen an-komm-INF],
        tran: [She will arrive tomorrow.],
      ),
    ),
  ),
)

#to-enum(format(xlist))

---

For numbering patterns with different ending markers for different levels, see Numbering patterns for nested lists is used incorrectly by the compiler · Issue #6088 · typst/typst · GitHub

More flexible separators in numbering patterns

[Mark_Hilton]

@Andrew

#let format(xlist, level: 0) = {
  // set enum(numbering: "1.a.i)")
  if type(xlist) == dictionary {
    xlist.values().map(smallcaps).join("\n")
  } else if type(xlist) == array {
    xlist.map(example => (format(example, level: level + 1),)).join()
  }
}

As a linguist beggining to use Typst, I am interested in this thread on formatting linguistic example lists and think I can follow how your code fits in with that by @quachpas.

I’m planning to try it, but in the code above, I understand the .map(smallcaps) putting the examples into smallcaps, but I would want my examples to to be in a monospaced font instead. How would I modify the code to achieve that?

[bluss]

map takes any function, the function receives a value and should return content here. We can generalize format so it can change formatting of the word:

#let format(xlist, level: 0, wordformat: smallcaps) = {
  // set enum(numbering: "1.a.i)")
  if type(xlist) == dictionary {
    xlist.values().map(wordformat).join("\n")
  } else if type(xlist) == array {
    xlist.map(example => (format(example, level: level + 1, wordformat: wordformat),)).join()
  }
}

Then you can pass wordformat: raw to the function. Or equivalently it => raw(it) (an anonymous function). Or use a different function than raw if there’s a better way to format the text, maybe using it => text(it) with more options added in.

#let format(xlist, level: 0, wordformat: smallcaps) = {
  // set enum(numbering: "1.a.i)")
  if type(xlist) == dictionary {
    xlist.values().map(wordformat).join("\n")
  } else if type(xlist) == array {
    xlist.map(example => (format(example, level: level + 1, wordformat: wordformat),)).join()
  }
}

#let to-enum(arr) = {
  set enum(numbering: "1.a.i)")
  arr
    .fold(
      (),
      (items, curr) => {
        // If the current entry is an array, append a new subenum to
        // the last item. Otherwise, create a new enum item.
        if type(curr) == array { items += (to-enum(curr),) } else {
          items.push(curr)
        }
        items
      },
    )
    .map(enum.item)
    .join()
}

#to-enum(format(
  (
    (
      sentence: "A sentence",
      gloss: "Gloss",
      tran: "Tran"
    ),
    (
      sentence: "A sentence",
      gloss: "Gloss",
      tran: "Tran"
    ),
  )
, wordformat: raw))

[Andrew]

There are 2 options: raw and text.with(font: "monospacedfont"). First one only works on strings, second works on strings and content types. Usually you would use raw one way or another, but here a conversion from content to str should be added that is relatively robust and easy:

#import "@preview/t4t:0.4.2": get

#let format(xlist, level: 0) = {
  if type(xlist) == dictionary {
    xlist.values().map(get.text).map(raw).join("\n")
  } else if type(xlist) == array {
    xlist.map(example => (format(example, level: level + 1),)).join()
  }
}

But if you will only ever use strings, then you don’t need that package function.

The less idiomatic way:

#let format(xlist, level: 0) = {
  if type(xlist) == dictionary {
    xlist.values().map(text.with(font: "Liberation Mono")).join("\n")
  } else if type(xlist) == array {
    xlist.map(example => (format(example, level: level + 1),)).join()
  }
}

Of course, if you need to, you can move out the formatting function into an input parameter like @bluss showed above.