Enum Expr 

pub enum Expr<'a> {
    Text(Text<'a>),
    Space(Space<'a>),
    Linebreak(Linebreak<'a>),
    Parbreak(Parbreak<'a>),
    Escape(Escape<'a>),
    Shorthand(Shorthand<'a>),
    SmartQuote(SmartQuote<'a>),
    Strong(Strong<'a>),
    Emph(Emph<'a>),
    Raw(Raw<'a>),
    Link(Link<'a>),
    Label(Label<'a>),
    Ref(Ref<'a>),
    Heading(Heading<'a>),
    ListItem(ListItem<'a>),
    EnumItem(EnumItem<'a>),
    TermItem(TermItem<'a>),
    Equation(Equation<'a>),
    Math(Math<'a>),
    MathText(MathText<'a>),
    MathIdent(MathIdent<'a>),
    MathFieldAccess(MathFieldAccess<'a>),
    MathShorthand(MathShorthand<'a>),
    MathAlignPoint(MathAlignPoint<'a>),
    MathCall(MathCall<'a>),
    MathDelimited(MathDelimited<'a>),
    MathAttach(MathAttach<'a>),
    MathPrimes(MathPrimes<'a>),
    MathFrac(MathFrac<'a>),
    MathRoot(MathRoot<'a>),
    Ident(Ident<'a>),
    None(None<'a>),
    Auto(Auto<'a>),
    Bool(Bool<'a>),
    Int(Int<'a>),
    Float(Float<'a>),
    Numeric(Numeric<'a>),
    Str(Str<'a>),
    CodeBlock(CodeBlock<'a>),
    ContentBlock(ContentBlock<'a>),
    Parenthesized(Parenthesized<'a>),
    Array(Array<'a>),
    Dict(Dict<'a>),
    Unary(Unary<'a>),
    Binary(Binary<'a>),
    FieldAccess(FieldAccess<'a>),
    FuncCall(FuncCall<'a>),
    Closure(Closure<'a>),
    LetBinding(LetBinding<'a>),
    DestructAssignment(DestructAssignment<'a>),
    SetRule(SetRule<'a>),
    ShowRule(ShowRule<'a>),
    Contextual(Contextual<'a>),
    Conditional(Conditional<'a>),
    WhileLoop(WhileLoop<'a>),
    ForLoop(ForLoop<'a>),
    ModuleImport(ModuleImport<'a>),
    ModuleInclude(ModuleInclude<'a>),
    LoopBreak(LoopBreak<'a>),
    LoopContinue(LoopContinue<'a>),
    FuncReturn(FuncReturn<'a>),
}

An expression in markup, math or code.

Variants

Text(Text<'a>)

Plain text without markup.

Space(Space<'a>)

Whitespace in markup or math. Has at most one newline in markup, as more indicate a paragraph break.

Linebreak(Linebreak<'a>)

A forced line break: \.

Parbreak(Parbreak<'a>)

A paragraph break, indicated by one or multiple blank lines.

Escape(Escape<'a>)

An escape sequence: \#, \u{1F5FA}.

Shorthand(Shorthand<'a>)

A shorthand for a unicode codepoint. For example, ~ for non-breaking space or -? for a soft hyphen.

SmartQuote(SmartQuote<'a>)

A smart quote: ' or ".

Strong(Strong<'a>)

Strong content: *Strong*.

Emph(Emph<'a>)

Emphasized content: _Emphasized_.

Raw(Raw<'a>)

Raw text with optional syntax highlighting: `...`.

Link(Link<'a>)

A hyperlink: https://typst.org.

Label(Label<'a>)

A label: <intro>.

Ref(Ref<'a>)

A reference: @target, @target[..].

Heading(Heading<'a>)

A section heading: = Introduction.

ListItem(ListItem<'a>)

An item in a bullet list: - ....

EnumItem(EnumItem<'a>)

An item in an enumeration (numbered list): + ... or 1. ....

TermItem(TermItem<'a>)

An item in a term list: / Term: Details.

Equation(Equation<'a>)

A mathematical equation: $x$, $ x^2 $.

Math(Math<'a>)

The contents of a mathematical equation: x^2 + 1.

MathText(MathText<'a>)

A lone text fragment in math: x, 25, 3.1415, =, [.

MathIdent(MathIdent<'a>)

An identifier in math: pi.

MathFieldAccess(MathFieldAccess<'a>)

A field access in math: arrow.r.long.double.bar.

MathShorthand(MathShorthand<'a>)

A shorthand for a unicode codepoint in math: a <= b.

MathAlignPoint(MathAlignPoint<'a>)

An alignment point in math: &.

MathCall(MathCall<'a>)

A function call in math: mat(delim: "[", a, b; ..#($c$,), d)

MathDelimited(MathDelimited<'a>)

Matched delimiters in math: [x + y].

MathAttach(MathAttach<'a>)

A base with optional attachments in math: a_1^2.

MathPrimes(MathPrimes<'a>)

Grouped primes in math: a'''.

MathFrac(MathFrac<'a>)

A fraction in math: x/2.

MathRoot(MathRoot<'a>)

A root in math: √x, ∛x or ∜x.

Ident(Ident<'a>)

An identifier: left.

None(None<'a>)

The none literal.

Auto(Auto<'a>)

The auto literal.

Bool(Bool<'a>)

A boolean: true, false.

Int(Int<'a>)

An integer: 120.

Float(Float<'a>)

A floating-point number: 1.2, 10e-4.

Numeric(Numeric<'a>)

A numeric value with a unit: 12pt, 3cm, 2em, 90deg, 50%.

Str(Str<'a>)

A quoted string: "...".

CodeBlock(CodeBlock<'a>)

A code block: { let x = 1; x + 2 }.

ContentBlock(ContentBlock<'a>)

A content block: [*Hi* there!].

Parenthesized(Parenthesized<'a>)

A grouped expression: (1 + 2).

Array(Array<'a>)

An array: (1, "hi", 12cm).

Dict(Dict<'a>)

A dictionary: (thickness: 3pt, dash: "solid").

Unary(Unary<'a>)

A unary operation: -x.

Binary(Binary<'a>)

A binary operation: a + b.

FieldAccess(FieldAccess<'a>)

A field access: properties.age.

FuncCall(FuncCall<'a>)

An invocation of a function or method: f(x, y).

Closure(Closure<'a>)

A closure: (x, y) => z.

LetBinding(LetBinding<'a>)

A let binding: let x = 1.

DestructAssignment(DestructAssignment<'a>)

A destructuring assignment: (x, y) = (1, 2).

SetRule(SetRule<'a>)

A set rule: set text(...).

ShowRule(ShowRule<'a>)

A show rule: show heading: it => emph(it.body).

Contextual(Contextual<'a>)

A contextual expression: context text.lang.

Conditional(Conditional<'a>)

An if-else conditional: if x { y } else { z }.

WhileLoop(WhileLoop<'a>)

A while loop: while x { y }.

ForLoop(ForLoop<'a>)

A for loop: for x in y { z }.

ModuleImport(ModuleImport<'a>)

A module import: import "utils.typ": a, b, c.

ModuleInclude(ModuleInclude<'a>)

A module include: include "chapter1.typ".

LoopBreak(LoopBreak<'a>)

A break from a loop: break.

LoopContinue(LoopContinue<'a>)

A continue in a loop: continue.

FuncReturn(FuncReturn<'a>)

A return from a function: return, return x + 1.

Implementations

impl Expr<'_>

pub fn hash(self) -> bool

Can this expression be embedded into markup with a hash?

pub fn is_literal(self) -> bool

Is this a literal?

Trait Implementations

impl<'a> AstNode<'a> for Expr<'a>

fn from_untyped(node: &'a SyntaxNode) -> Option<Self>

Convert a node into its typed variant.

fn to_untyped(self) -> &'a SyntaxNode

A reference to the underlying syntax node.

fn placeholder() -> Self

A placeholder for this node type. If the underlying CST has syntax errors or did not come from the parser, the AST is not guaranteed to be valid. But instead of panicking in that case, we return placeholder nodes.

fn span(self) -> Span

The source code location.

impl<'a> Clone for Expr<'a>

fn clone(&self) -> Expr<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for Expr<'a>

impl<'a> Debug for Expr<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Hash for Expr<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.