Enum ArgPattern

pub enum ArgPattern {
    None,
    FixedLenTerm {
        len: u8,
    },
    RangeLenTerm {
        min: u8,
        max: u8,
    },
    Greedy,
    Glob {
        pattern: GlobStr,
    },
}

An efficient pattern used for argument matching.

There are four kinds of pattern. The most powerful one is ArgPattern::Glob, which matches an sequence of input as arguments. Among these four kinds, ArgPattern::Glob can already match all possible inputs in our use cases. But one should specify a fixed length pattern (ArgPattern::FixedLenTerm), a range length pattern (ArgPattern::RangeLenTerm), or a greedy pattern (ArgPattern::Greedy) to achieve better performance.

Let us look at usage of a glob pattern by \sqrt, which is {,b}t.

• Example 1. For \sqrt{2}{3}, parser requires the pattern to match with an encoded string tt. Here, {,b}t matches and yields the string t (which corresponds to {2}).

• Example 2. For \sqrt[1]{2}{2}, parser requires the pattern to match with an encoded string btt. Here, {,b}t matches and yields the string bt (which corresponds to [1]{2}).

Kinds of item to match:

• Bracket/b: []
• Parenthesis/p: ()
• Term/t: any remaining terms, typically {} or a single char

Note: any prefix of the argument pattern are matched during the parse stage, so you need to check whether it is complete in later stages.

Variants

None

No arguments are passed, i.e. this is processed as a variable in Typst.

E.g. \alpha => $alpha$, where \alpha has an argument pattern of None

FixedLenTerm

Fixed length pattern, equivalent to repeat {,t} for x times

E.g. \hat x y => $hat(x) y$, where \hat has an argument pattern of FixedLenTerm(1)

E.g. 1 \sum\limits => $1 limits(sum)$, where \limits has an argument pattern of FixedLenTerm(1)

Fields

len: u8

The length of the arguments should be matched

RangeLenTerm

Range length pattern (matches as much as possible), equivalent to repeat t for x times, then repeat {,t} for y times.

No example

Fields

min: u8

The minimum length of the arguments should be matched

max: u8

The maximum length of the arguments should be matched

Greedy

Receives any items as much as possible, equivalent to *.

E.g. \over, \displaystyle

Glob

The most powerful pattern, but slightly slow. Note that the glob must accept the whole prefix of the input.

E.g. \sqrt has a glob argument pattern of {,b}t

Description of the glob pattern:

• {,b}: first, it matches a bracket option, e.g. \sqrt[3]
• t: it then matches a single term, e.g. \sqrt[3]{a} or \sqrt{a}

Fields

pattern: GlobStr

The glob pattern to match the arguments

Trait Implementations

impl Archive for ArgPattern

where u8: Archive, GlobStr: Archive,

type Archived = ArchivedArgPattern

The archived representation of this type.

type Resolver = ArgPatternResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <ArgPattern as Archive>::Resolver, out: *mut <ArgPattern as Archive>::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for ArgPattern

fn clone(&self) -> ArgPattern

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ArgPattern

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ArgPattern

fn deserialize<__D>( __deserializer: __D, ) -> Result<ArgPattern, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D> Deserialize<ArgPattern, __D> for <ArgPattern as Archive>::Archived

where __D: Fallible + ?Sized, u8: Archive, <u8 as Archive>::Archived: Deserialize<u8, __D>, GlobStr: Archive, <GlobStr as Archive>::Archived: Deserialize<GlobStr, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ArgPattern, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S> Serialize<__S> for ArgPattern

where __S: Fallible + ?Sized, u8: Serialize<__S>, GlobStr: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<ArgPattern as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for ArgPattern

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.