代码模式：值、类型与控制流

1
lab/ch02/
2
├── types.typ
3
├── strings.typ
4
├── collections.typ
5
├── control.typ
6
├── str-index.fail.typ
7
└── type-error.fail.typ

1
$ make ch02
2
./scripts/chapter.sh ch02
3
ok   lab/ch02/collections.typ
4
ok   lab/ch02/control.typ
5
ok   lab/ch02/str-index.fail.typ (failed as expected)
6
ok   lab/ch02/strings.typ
7
ok   lab/ch02/type-error.fail.typ (failed as expected)
8
ok   lab/ch02/types.typ

1
$ typst compile --root . modes.typ modes.pdf && pdftotext modes.pdf -
2
Markup: n 是 3，name 是 Typst. Field: 5 个字节，4 与 3+1 与 3+1。 Math: 𝑛2 = 9 与 Typst 与
3
text。 Content in code: 粗 与 斜，拼接 Content arg: 参数 红色 Typst Strings in content: *不是粗体
4
* 与 粗体。 Escape: #n 与 $。 ab

1
$ typst eval '(2cm + 5mm, 50% + 10pt, 2fr + 1fr)'
2
["70.87pt","50% + 10pt","3fr"]

1
// Floats are binary, decimals are not.
2
#assert(0.1 + 0.2 != 0.3)
3
#assert.eq(decimal("0.1") + decimal("0.2"), decimal("0.3"))
4

5
// Integers are 64 bit; 0.15 added `int.min` and `int.max`.
6
#assert.eq(int.max, 9223372036854775807)
7
#assert.eq(int.min, -9223372036854775808)

1
error: value is too large
2
  ┌─ overflow.typ:1:2
3
  │
4
1 │ #(int.max + 1)
5
  │   ^^^^^^^^^^^

1
// Units convert through methods.
2
#assert.eq(2.5cm.mm(), 25.0)
3
#assert.eq((1em + 3pt).em, 1.0)
4
#assert(calc.abs(90deg.rad() - calc.pi / 2) < 1e-12)
5

6
// Versions compare component-wise.
7
#assert(version(0, 15, 1) > version(0, 14))
8
#assert(sys.version >= version(0, 15, 1))

1
#assert.eq(type(none), type(none))
2
#assert.eq(type(42), int)
3
#assert.eq(type(3.14), float)
4
#assert.eq(type(1em + 3pt), length)
5
#assert.eq(type(50% + 2pt), relative)

1
// A str is UTF-8: len() counts bytes, not characters.
2
#let s = "中文"
3
#assert.eq(s.len(), 6)
4
#assert.eq(s.clusters().len(), 2)
5
#assert.eq(s.codepoints().len(), 2)
6

7
// A decomposed é is one grapheme cluster but two codepoints and three bytes.
8
#let e = "e\u{0301}"
9
#assert.eq(e.len(), 3)
10
#assert.eq(e.codepoints().len(), 2)
11
#assert.eq(e.clusters().len(), 1)

1
#table(
2
  columns: 4,
3
  [*str*], [*bytes*], [*codepoints*], [*clusters*],
4
  ..(s, e, "abc")
5
    .map(x => (
6
      raw(repr(x)),
7
      str(x.len()),
8
      str(x.codepoints().len()),
9
      str(x.clusters().len()),
10
    ))
11
    .flatten(),
12
)

1
str          bytes codepoints clusters
2
"中文"         6     2           2
3
"e\u{301}"   3     2           1
4
"abc"        3     3           3

1
// Slicing takes byte offsets and must land on a character boundary.
2
#assert.eq(s.slice(0, 3), "中")
3
#assert.eq(s.at(3), "文")

1
// Byte offset 1 is inside the three-byte character 中.
2
#"中文".slice(1)

1
error: string index 1 is not a character boundary
2
  ┌─ lab/ch02/str-index.fail.typ:2:1
3
  │
4
2 │ #"中文".slice(1)
5
  │  ^^^^^^^^^^^^^^^

1
// Conversions and searching.
2
#assert.eq("中".to-unicode(), 20013)
3
#assert.eq(str.from-unicode(20013), "中")
4
#assert.eq("a,b,,c".split(","), ("a", "b", "", "c"))
5
#assert.eq("  trim me ".trim(), "trim me")
6
#assert.eq("Typst".replace(regex("[aeiou]"), "_"), "Typst")
7
#assert.eq("2026-10-19".find(regex("\d+")), "2026")
8
#assert.eq("ab" * 3, "ababab")
9
#assert.eq(upper("typst"), "TYPST")

1
// Typst never coerces between types.
2
#("1" + 1)

1
error: cannot add string and integer
2
  ┌─ lab/ch02/type-error.fail.typ:2:2
3
  │
4
2 │ #("1" + 1)
5
  │   ^^^^^^^

1
// `let` binds; a later `let` shadows, the old value is untouched.
2
#let x = 1
3
#let f() = x
4
#let x = 2
5
#assert.eq(f(), 1)
6
#assert.eq(x, 2)

1
// Destructuring in `let` and in `for`.
2
#let (first, ..rest) = xs
3
#assert.eq(first, 3)
4
#assert.eq(rest, (1, 2, 3, 1))
5
#for (k, v) in d [#k: #repr(v) \ ]
6
#for (i, x) in xs.enumerate() [#i=#x #h(0.5em)]

1
name: "Typst"
2
year: 2023
3
stable: true
4
0=3 1=1 2=2 3=3 4=1

1
// if / else is an expression.
2
#let sign(n) = if n > 0 { 1 } else if n < 0 { -1 } else { 0 }
3
#assert.eq((-5, 0, 7).map(sign), (-1, 0, 1))

1
// Code blocks join the values of their statements (strings with strings,
2
// content with content; mixing a string and an integer is an error).
3
#let joined = {
4
  "a"
5
  "b"
6
}
7
#assert.eq(joined, "ab")

1
$ cat joinerr.typ
2
#{
3
  "a"
4
  3
5
}
6
$ typst compile --root . joinerr.typ x.pdf
7
error: cannot join string with integer
8
  ┌─ joinerr.typ:3:2
9
  │
10
3 │   3
11
  │   ^

1
// Embedding code in markup: `#` takes the longest valid expression.
2
Collatz(27) = #collatz(27) 步，奇数 #odds.map(str).join("、")。
3
#("一" + "二")，#(1 + 2) 与 #1+2 不同：后者先输出 1。

1
Collatz(27) = 111 步，奇数 1、3、5、7。 一二，3 与 1+2 不同：后者先
2
输出 1。

1
$ typst eval '(1 + 2 * 3 - 4, 2 in (1, 2, 3), "ell" in "hello", "x" in (x: 1))'
2
[3,true,true,true]

1
$ typst eval '(1 == 1.0, "a" < "b", (1, 2) == (1, 2), (a: 1) == (a: 1), 7 - -2)'
2
[true,true,true,true,9]
3
$ typst eval '(calc.pow(2, 10), calc.round(3.14159, digits: 2), calc.clamp(15, 0, 10), calc.gcd(12, 18))'
4
[1024,3.14,10,6]
5
$ typst eval 'if none { 1 } else { 2 }'
6
error: expected boolean, found none
7
  ┌─ <input-expression>:1:3
8
  │
9
1 │ if none { 1 } else { 2 }
10
  │    ^^^^

1
// Arrays
2
#let xs = (3, 1, 2, 3, 1)
3
#assert.eq(xs.map(x => x * x), (9, 1, 4, 9, 1))
4
#assert.eq(xs.filter(x => x > 1), (3, 2, 3))
5
#assert.eq(xs.fold(0, (sum, x) => sum + x), 10)
6
#assert.eq(xs.dedup(), (3, 1, 2))
7
#assert.eq(xs.sorted(), (1, 1, 2, 3, 3))
8
#assert.eq(xs.sorted(key: x => -x), (3, 3, 2, 1, 1))
9
#assert.eq(("a", "b").enumerate(), ((0, "a"), (1, "b")))
10
#assert.eq(("a", "b").zip((1, 2)), (("a", 1), ("b", 2)))
11
#assert.eq(("a", "b", "c").join(", "), "a, b, c")
12
#assert.eq(range(1, 5, inclusive: true), (1, 2, 3, 4, 5))
13
#assert.eq(xs.at(10, default: none), none)

1
$ typst eval '(1, 2, 3).at(5)'
2
error: array index out of bounds (index: 5, len: 3) and no default value was specified
3
  ┌─ <input-expression>:1:0
4
  │
5
1 │ (1, 2, 3).at(5)
6
  │ ^^^^^^^^^^^^^^^

1
// Dictionaries keep insertion order.
2
#let d = (name: "Typst", year: 2023, stable: true)
3
#assert.eq(d.keys(), ("name", "year", "stable"))
4
#assert.eq(d.at("version", default: "?"), "?")
5

6
// 0.15: `map` and `filter` on a dictionary act on the values.
7
#assert.eq((a: 1, b: 2, c: 3).map(v => v * 2), (a: 2, b: 4, c: 6))
8
#assert.eq((a: 1, b: 2, c: 3).filter(v => v > 1), (b: 2, c: 3))

1
$ cat assert.typ
2
#assert(1 + 1 == 3, message: "arithmetic is broken")
3
$ typst compile --root . assert.typ x.pdf
4
error: assertion failed: arithmetic is broken
5
  ┌─ assert.typ:1:1
6
  │
7
1 │ #assert(1 + 1 == 3, message: "arithmetic is broken")
8
  │  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

1
$ cat asserteq.typ
2
#assert.eq(2 * 3, 7)
3
$ typst compile --root . asserteq.typ x.pdf
4
error: equality assertion failed: value 6 was not equal to 7
5
  ┌─ asserteq.typ:1:1
6
  │
7
1 │ #assert.eq(2 * 3, 7)
8
  │  ^^^^^^^^^^^^^^^^^^^

1
#let area(w, h) = {
2
  if w < 0 or h < 0 { panic("negative side: " + repr((w, h))) }
3
  w * h
4
}
5
#area(3, -2)

1
$ typst compile --root . panic.typ panic.pdf; echo "exit=$?"
2
error: panicked with: negative side: (3, -2)
3
  ┌─ panic.typ:2:22
4
  │
5
2 │   if w < 0 or h < 0 { panic("negative side: " + repr((w, h))) }
6
  │                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
7

8
  while calling `area` at panic.typ:5:1
9
    area(3, -2)
10

11
exit=1

1
error: panicked with: path: C:\data\"x", second, 42
2
  ┌─ panic2.typ:1:1
3
  │
4
1 │ #panic("path: C:\\data\\\"x\"", "second", 42)
5
  │  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

1
$ typst eval 'repr([*a* b])'
2
"sequence(strong(body: [a]), [ ], [b])"

1
$ typst eval '"中文".slice(0, 3) + "!" * 2'
2
"中!!"