Enum rune::ast::Expr

#[non_exhaustive]
pub enum Expr {
    Path(Path),
    Assign(ExprAssign),
    While(ExprWhile),
    Loop(ExprLoop),
    For(ExprFor),
    Let(ExprLet),
    If(ExprIf),
    Match(ExprMatch),
    Call(ExprCall),
    FieldAccess(ExprFieldAccess),
    Binary(ExprBinary),
    Unary(ExprUnary),
    Index(ExprIndex),
    Break(ExprBreak),
    Continue(ExprContinue),
    Yield(ExprYield),
    Block(ExprBlock),
    Return(ExprReturn),
    Await(ExprAwait),
    Try(ExprTry),
    Select(ExprSelect),
    Closure(ExprClosure),
    Lit(ExprLit),
    Object(ExprObject),
    Tuple(ExprTuple),
    Vec(ExprVec),
    Range(ExprRange),
    Empty(ExprEmpty),
    Group(ExprGroup),
    MacroCall(MacroCall),
}

A rune expression.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Path(Path)

An path expression.

Assign(ExprAssign)

An assign expression.

While(ExprWhile)

A while loop.

Loop(ExprLoop)

An unconditional loop.

For(ExprFor)

An for loop.

Let(ExprLet)

A let expression.

If(ExprIf)

An if expression.

Match(ExprMatch)

An match expression.

Call(ExprCall)

A function call,

FieldAccess(ExprFieldAccess)

A field access on an expression.

Binary(ExprBinary)

A binary expression.

Unary(ExprUnary)

A unary expression.

Index(ExprIndex)

An index set operation.

Break(ExprBreak)

A break expression.

Continue(ExprContinue)

A continue expression.

Yield(ExprYield)

A yield expression.

Block(ExprBlock)

A block as an expression.

Return(ExprReturn)

A return statement.

Await(ExprAwait)

An await expression.

Try(ExprTry)

Try expression.

Select(ExprSelect)

A select expression.

Closure(ExprClosure)

A closure expression.

Lit(ExprLit)

A literal expression.

Object(ExprObject)

An object literal

Tuple(ExprTuple)

A tuple literal

Vec(ExprVec)

A vec literal

Range(ExprRange)

A range expression.

Empty(ExprEmpty)

A grouped empty expression.

Group(ExprGroup)

A grouped expression.

MacroCall(MacroCall)

A macro call,

Trait Implementations

impl Debug for Expr

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

Formats the value using the given formatter.

impl OptionSpanned for Expr

fn option_span(&self) -> Option<Span>

Get the optional span of the type.

impl Parse for Expr

fn parse(p: &mut Parser<'_>) -> Result<Self, Error>

Parse the current item from the parser.

impl PartialEq for Expr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Peek for Expr

fn peek(p: &mut Peeker<'_>) -> bool

Peek the parser for the given token.

impl Spanned for Expr

fn span(&self) -> Span

Get the span of the type.

impl ToTokens for Expr

fn to_tokens( &self, context: &mut MacroContext<'_, '_, '_>, stream: &mut TokenStream ) -> Result<()>

Turn the current item into tokens.

impl TryClone for Expr

fn try_clone(&self) -> Result<Self>

Try to clone the current value, raising an allocation error if it’s unsuccessful.

fn try_clone_from(&mut self, source: &Self) -> Result<(), Error>

Performs copy-assignment from source.

impl Eq for Expr

impl StructuralPartialEq for Expr