How to format linguistic example lists?

Questions
1

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:

2025-03-28_16-00

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.

2

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)").

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))

image
image397×575 46.4 KB

2 Likes
3

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))

image

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

1 Like
4

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?

5

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.

bild

#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))
6

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.

7

not shorter but imo clearer than the fold:

#let to-enum(elem) = {
  if type(elem) != array {
    return elem
  }

  set enum(numbering: "1.a.i)")
  for e in elem [+ #to-enum(e)]
}
8

tl;dr…

Is what you need covered by leipzig-glossing?