Enum texlang::variable::Variable

pub enum Variable<S> {
    Int(TypedVariable<S, i32>),
    CatCode(TypedVariable<S, CatCode>),
    MathCode(TypedVariable<S, MathCode>),
    TokenList(TypedVariable<S, Vec<Token>>),
}

TeX variable of any type.

A variable uniquely identifies a Rust value in the state, like an i32. Operations on this value (like reading or setting the value) can be done in two ways:

1. (Easy, less flexible) Use the methods directly on this type like Variable::value to read the value. These methods are really ergonomic. The problem with the value method specifically is that the result is a reference which keeps the borrow of the state alive. Thus, while holding onto the result of the value, you can’t do anything this the input stream like reading an argument. This is especially a problem when you need to perform a different action depending on the concrete type of the variable.

2. (Trickier, more flexible) Match on the type’s enum variants to determine the concrete type of the variable. The TypedVariable value obtained in this way can be used to perform operations on the value. The main benefit of this approach is that after matching on the type, you can still use the input stream to do things because there is not borrow alive.

Variants

Int(TypedVariable<S, i32>)

CatCode(TypedVariable<S, CatCode>)

MathCode(TypedVariable<S, MathCode>)

TokenList(TypedVariable<S, Vec<Token>>)

Implementations

impl<S: TexlangState> Variable<S>

pub fn value<'a>(&self, state: &'a S) -> ValueRef<'a>

Return a reference to the value of the variable.

Trait Implementations

impl<S: TexlangState> Parsable<S> for Variable<S>

fn parse_impl(input: &mut ExpandedStream<S>) -> Result<Self, Box<Error>>

Parses a value from the vm::ExpandedStream.

fn parse<I>(input: &mut I) -> Result<Self, Box<Error>>where I: AsMut<ExpandedStream<S>>,

Parses a value from an input stream.