typst/docs/reference/categories.yml

# Descriptions of the documentation categories.

foundations: |
  Foundational types and functions.

  Here, you'll find documentation for basic data types like [integers]($int) and
  [strings]($int) as well as details about core computational functions.

text: |
  Text styling.

  The [text function]($text) is of particular interest.

math: |
  Typst has special [syntax]($syntax/#math) and library functions to typeset
  mathematical formulas. Math formulas can be displayed inline with text or as
  separate blocks. They will be typeset into their own block if they start and
  end with at least one space (e.g. `[$ x^2 $]`).

  In math, single letters are always displayed as is. Multiple letters, however,
  are interpreted as variables and functions. To display multiple letters
  verbatim, you can place them into quotes and to access single letter
  variables, you can use the [hashtag syntax]($scripting/#expressions).

  ```example
  $ A = pi r^2 $
  $ "area" = pi dot "radius"^2 $
  $ cal(A) :=
      { x in RR | x "is natural" } $
  #let x = 5
  $ #x < 17 $
  ```

  Math mode makes a wide selection of [symbols]($category/symbols/sym) like
  `pi`, `dot`, or `RR` available. Many mathematical symbols are available in
  different variants. You can select between different variants by applying
  [modifiers]($symbol) to the symbol. Typst further recognizes a number of
  shorthand sequences like `=>` that approximate a symbol. When such a shorthand
  exists, the symbol's documentation lists it.

  ```example
  $ x < y => x gt.eq.not y $
  ```

  Formulas can also contain line breaks. Each line can contain one or multiple
  _alignment points_ (`&`) which are then aligned.

  ```example
  $ sum_(k=0)^n k
      &= 1 + ... + n \
      &= (n(n+1)) / 2 $
  ```

  Math mode supports special function calls without the hashtag prefix. In these
  "math calls", the argument list works a little differently than in code:

  - Within them, Typst is still in "math mode". Thus, you can write math
    directly into them, but need to use hashtag syntax to pass code expressions
    (except for strings, which are available in the math syntax).
  - They support positional and named arguments, but don't support trailing
    content blocks and argument spreading.
  - They provide additional syntax for 2-dimensional argument lists. The
    semicolon (`;`) merges preceding arguments separated by commas into an array
    argument.

  ```example
  $ frac(a^2, 2) $
  $ vec(1, 2, delim: "[") $
  $ mat(1, 2; 3, 4) $
  $ lim_x =
      op("lim", limits: #true)_x $
  ```

  To write a verbatim comma or semicolon in a math call, escape it with a
  backslash. The colon on the other hand is only recognized in a special way if
  directly preceded by an identifier, so to display it verbatim in those cases,
  you can just insert a space before it.

  Functions calls preceded by a hashtag are normal code function calls and not
  affected by these rules.

  All math functions are part of the `math` [module]($scripting/#modules), which
  is available by default in equations. Outside of equations, they can be
  accessed with the `math.` prefix. For example, to set the font used for
  equations, write:

  ```example
  #show math.equation: set text(font: "Fira Math")
  $ sum_(i in NN) 1 + i $
  ```

layout: |
  Arranging elements on the page in different ways.

  By combining layout functions, you can create complex and automatic layouts.

visualize: |
  Drawing and data visualization.

  _Note:_ Functions for plotting and diagrams are not yet available. They will
  be in the future.

meta: |
  Document structuring, introspection, and metadata configuration.

  Here, you can find functions to structure your document and interact with that
  structure. This includes section headings and figures, bibliography
  management, cross-referencing and more.

  Moreover, this category is home to Typst's introspection capabilities: With
  the `counter` function, you can access and manipulate page, section, figure,
  and equation counters or create custom ones. And the `query` function lets you
  search for elements in the document to construct things like a list of
  figures or headers which show the current chapter title.

symbols: |
  These two modules give names to symbols and emoji to make them easy to insert
  with a normal keyboard. Alternatively, you can also always directly enter
  Unicode symbols into your text and formulas. In addition to the symbols listed
  below, math mode defines `dif` and `Dif`. These are not normal symbol values
  because they also affect spacing and font style.

sym: |
  Named general symbols.

  For example, `#sym.arrow` produces the → symbol. Within
  [formulas]($category/math), these symbols can be used without the `#sym.`
  prefix.

  The `d` in an integral's `dx` can be written as `[$dif x$]`.
  Outside math formulas, `dif` can be accessed as `math.dif`.

emoji: |
  Named emoji.

  For example, `#emoji.face` produces the 😀 emoji. If you frequently use
  certain emojis, you can also import them from the `emoji` module (`[#import
  emoji: face]`) to use them without the `#emoji.` prefix.

data-loading: |
  Data loading from external files.

  These functions help you with loading and embedding data, for example from
  the results of an experiment.

packages: |
  Typst [packages]($scripting/#packages) encapsulate reusable building blocks
  and make them reusable across projects. Below is a list of Typst packages
  created by the community. Due to the early and experimental nature of Typst's
  package management, they all live in a `preview` namespace. Click on a
  package's name to view its documentation and use the copy button on the right
  to get a full import statement for it.