Enum AstExpr 

pub enum AstExpr {
    As(IdentWithToken, Shared<Node>),
    Block(Program),
    Call(IdentWithToken, SmallVec<[Shared<Node>; 4]>),
    CallDynamic(Shared<Node>, SmallVec<[Shared<Node>; 4]>),
    Def(IdentWithToken, Params, Program),
    Macro(IdentWithToken, Params, Shared<Node>),
    Fn(Params, Program),
    Let(Pattern, Shared<Node>),
    Loop(Program),
    Var(Pattern, Shared<Node>),
    Assign(IdentWithToken, Shared<Node>),
    And(Vec<Shared<Node>>),
    Or(Vec<Shared<Node>>),
    Literal(Literal),
    Ident(IdentWithToken),
    InterpolatedString(Vec<StringSegment>),
    Selector(Selector),
    SelectorChain(SmallVec<[Selector; 4]>),
    SelectorCall(Selector, SmallVec<[Shared<Node>; 4]>),
    While(Shared<Node>, Program),
    Foreach(IdentWithToken, Shared<Node>, Program),
    If(SmallVec<[(Option<Shared<Node>>, Shared<Node>); 4]>),
    Match(Shared<Node>, SmallVec<[MatchArm; 4]>),
    Include(Literal),
    Import(Literal),
    Module(IdentWithToken, Program),
    QualifiedAccess(Vec<IdentWithToken>, AccessTarget),
    Self_,
    Nodes,
    Paren(Shared<Node>),
    Quote(Shared<Node>),
    Unquote(Shared<Node>),
    Try(Shared<Node>, Shared<Node>),
    Break(Option<Shared<Node>>),
    Continue,
}

Variants

As(IdentWithToken, Shared<Node>)

Block(Program)

Call(IdentWithToken, SmallVec<[Shared<Node>; 4]>)

CallDynamic(Shared<Node>, SmallVec<[Shared<Node>; 4]>)

Def(IdentWithToken, Params, Program)

Macro(IdentWithToken, Params, Shared<Node>)

Fn(Params, Program)

Let(Pattern, Shared<Node>)

Loop(Program)

Var(Pattern, Shared<Node>)

Assign(IdentWithToken, Shared<Node>)

And(Vec<Shared<Node>>)

Or(Vec<Shared<Node>>)

Literal(Literal)

Ident(IdentWithToken)

InterpolatedString(Vec<StringSegment>)

Selector(Selector)

SelectorChain(SmallVec<[Selector; 4]>)

A sequence of selectors merged by the optimizer to reduce pipeline overhead.

Equivalent to applying each selector in order, but evaluated in a single eval_expr call instead of N separate pipeline steps.

SelectorCall(Selector, SmallVec<[Shared<Node>; 4]>)

A selector with runtime-evaluated arguments for filtered matching.

Supports .h(1..2), .h(1, 2), .code("rust"), etc.

While(Shared<Node>, Program)

Foreach(IdentWithToken, Shared<Node>, Program)

If(SmallVec<[(Option<Shared<Node>>, Shared<Node>); 4]>)

Match(Shared<Node>, SmallVec<[MatchArm; 4]>)

Include(Literal)

Import(Literal)

Module(IdentWithToken, Program)

QualifiedAccess(Vec<IdentWithToken>, AccessTarget)

Self_

Nodes

Paren(Shared<Node>)

Quote(Shared<Node>)

Unquote(Shared<Node>)

Try(Shared<Node>, Shared<Node>)

Break(Option<Shared<Node>>)

Continue

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Expr

fn partial_cmp(&self, other: &Expr) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Expr