Enum syn::Expr

pub enum Expr {
    Array(ExprArray),
    Assign(ExprAssign),
    AssignOp(ExprAssignOp),
    Async(ExprAsync),
    Await(ExprAwait),
    Binary(ExprBinary),
    Block(ExprBlock),
    Box(ExprBox),
    Break(ExprBreak),
    Call(ExprCall),
    Cast(ExprCast),
    Closure(ExprClosure),
    Continue(ExprContinue),
    Field(ExprField),
    ForLoop(ExprForLoop),
    Group(ExprGroup),
    If(ExprIf),
    Index(ExprIndex),
    Let(ExprLet),
    Lit(ExprLit),
    Loop(ExprLoop),
    Macro(ExprMacro),
    Match(ExprMatch),
    MethodCall(ExprMethodCall),
    Paren(ExprParen),
    Path(ExprPath),
    Range(ExprRange),
    Reference(ExprReference),
    Repeat(ExprRepeat),
    Return(ExprReturn),
    Struct(ExprStruct),
    Try(ExprTry),
    TryBlock(ExprTryBlock),
    Tuple(ExprTuple),
    Type(ExprType),
    Unary(ExprUnary),
    Unsafe(ExprUnsafe),
    Verbatim(TokenStream),
    While(ExprWhile),
    Yield(ExprYield),
    // some variants omitted
}

A Rust expression.

This type is available if Syn is built with the "derive" or "full" feature.

Syntax tree enums

This type is a syntax tree enum. In Syn this and other syntax tree enums are designed to be traversed using the following rebinding idiom.

let expr: Expr = /* ... */;
match expr {
    Expr::MethodCall(expr) => {
        /* ... */
    }
    Expr::Cast(expr) => {
        /* ... */
    }
    Expr::If(expr) => {
        /* ... */
    }

    /* ... */

We begin with a variable expr of type Expr that has no fields (because it is an enum), and by matching on it and rebinding a variable with the same name expr we effectively imbue our variable with all of the data fields provided by the variant that it turned out to be. So for example above if we ended up in the MethodCall case then we get to use expr.receiver, expr.args etc; if we ended up in the If case we get to use expr.cond, expr.then_branch, expr.else_branch.

This approach avoids repeating the variant names twice on every line.

// Repetitive; recommend not doing this.
match expr {
    Expr::MethodCall(ExprMethodCall { method, args, .. }) => {

In general, the name to which a syntax tree enum variant is bound should be a suitable name for the complete syntax tree enum type.

// Binding is called `base` which is the name I would use if I were
// assigning `*discriminant.base` without an `if let`.
if let Expr::Tuple(base) = *discriminant.base {

A sign that you may not be choosing the right variable names is if you see names getting repeated in your code, like accessing receiver.receiver or pat.pat or cond.cond.

Variants

Array(ExprArray)

A slice literal expression: [a, b, c, d].

Assign(ExprAssign)

An assignment expression: a = compute().

AssignOp(ExprAssignOp)

A compound assignment expression: counter += 1.

Async(ExprAsync)

An async block: async { ... }.

Await(ExprAwait)

An await expression: fut.await.

Binary(ExprBinary)

A binary operation: a + b, a * b.

Block(ExprBlock)

A blocked scope: { ... }.

Box(ExprBox)

A box expression: box f.

Break(ExprBreak)

A break, with an optional label to break and an optional expression.

Call(ExprCall)

A function call expression: invoke(a, b).

Cast(ExprCast)

A cast expression: foo as f64.

Closure(ExprClosure)

A closure expression: |a, b| a + b.

Continue(ExprContinue)

A continue, with an optional label.

Field(ExprField)

Access of a named struct field (obj.k) or unnamed tuple struct field (obj.0).

ForLoop(ExprForLoop)

A for loop: for pat in expr { ... }.

Group(ExprGroup)

An expression contained within invisible delimiters.

This variant is important for faithfully representing the precedence of expressions and is related to None-delimited spans in a TokenStream.

If(ExprIf)

An if expression with an optional else block: if expr { ... } else { ... }.

The else branch expression may only be an If or Block expression, not any of the other types of expression.

Index(ExprIndex)

A square bracketed indexing expression: vector[2].

Let(ExprLet)

A let guard: let Some(x) = opt.

Lit(ExprLit)

A literal in place of an expression: 1, "foo".

Loop(ExprLoop)

Conditionless loop: loop { ... }.

Macro(ExprMacro)

A macro invocation expression: format!("{}", q).

Match(ExprMatch)

A match expression: match n { Some(n) => {}, None => {} }.

MethodCall(ExprMethodCall)

A method call expression: x.foo::<T>(a, b).

Paren(ExprParen)

A parenthesized expression: (a + b).

Path(ExprPath)

A path like std::mem::replace possibly containing generic parameters and a qualified self-type.

A plain identifier like x is a path of length 1.

Range(ExprRange)

A range expression: 1..2, 1.., ..2, 1..=2, ..=2.

Reference(ExprReference)

A referencing operation: &a or &mut a.

Repeat(ExprRepeat)

An array literal constructed from one repeated element: [0u8; N].

Return(ExprReturn)

A return, with an optional value to be returned.

Struct(ExprStruct)

A struct literal expression: Point { x: 1, y: 1 }.

The rest provides the value of the remaining fields as in S { a: 1, b: 1, ..rest }.

Try(ExprTry)

A try-expression: expr?.

TryBlock(ExprTryBlock)

A try block: try { ... }.

Tuple(ExprTuple)

A tuple expression: (a, b, c, d).

Type(ExprType)

A type ascription expression: foo: f64.

Unary(ExprUnary)

A unary operation: !x, *x.

Unsafe(ExprUnsafe)

An unsafe block: unsafe { ... }.

Verbatim(TokenStream)

Tokens in expression position not interpreted by Syn.

While(ExprWhile)

A while loop: while expr { ... }.

Yield(ExprYield)

A yield expression: yield expr.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy 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 Eq for Expr

impl From<ExprArray> for Expr

fn from(e: ExprArray) -> Expr

Performs the conversion.

impl From<ExprAssign> for Expr

fn from(e: ExprAssign) -> Expr

Performs the conversion.

impl From<ExprAssignOp> for Expr

fn from(e: ExprAssignOp) -> Expr

Performs the conversion.

impl From<ExprAsync> for Expr

fn from(e: ExprAsync) -> Expr

Performs the conversion.

impl From<ExprAwait> for Expr

fn from(e: ExprAwait) -> Expr

Performs the conversion.

impl From<ExprBinary> for Expr

fn from(e: ExprBinary) -> Expr

Performs the conversion.

impl From<ExprBlock> for Expr

fn from(e: ExprBlock) -> Expr

Performs the conversion.

impl From<ExprBox> for Expr

fn from(e: ExprBox) -> Expr

Performs the conversion.

impl From<ExprBreak> for Expr

fn from(e: ExprBreak) -> Expr

Performs the conversion.

impl From<ExprCall> for Expr

fn from(e: ExprCall) -> Expr

Performs the conversion.

impl From<ExprCast> for Expr

fn from(e: ExprCast) -> Expr

Performs the conversion.

impl From<ExprClosure> for Expr

fn from(e: ExprClosure) -> Expr

Performs the conversion.

impl From<ExprContinue> for Expr

fn from(e: ExprContinue) -> Expr

Performs the conversion.

impl From<ExprField> for Expr

fn from(e: ExprField) -> Expr

Performs the conversion.

impl From<ExprForLoop> for Expr

fn from(e: ExprForLoop) -> Expr

Performs the conversion.

impl From<ExprGroup> for Expr

fn from(e: ExprGroup) -> Expr

Performs the conversion.

impl From<ExprIf> for Expr

fn from(e: ExprIf) -> Expr

Performs the conversion.

impl From<ExprIndex> for Expr

fn from(e: ExprIndex) -> Expr

Performs the conversion.

impl From<ExprLet> for Expr

fn from(e: ExprLet) -> Expr

Performs the conversion.

impl From<ExprLit> for Expr

fn from(e: ExprLit) -> Expr

Performs the conversion.

impl From<ExprLoop> for Expr

fn from(e: ExprLoop) -> Expr

Performs the conversion.

impl From<ExprMacro> for Expr

fn from(e: ExprMacro) -> Expr

Performs the conversion.

impl From<ExprMatch> for Expr

fn from(e: ExprMatch) -> Expr

Performs the conversion.

impl From<ExprMethodCall> for Expr

fn from(e: ExprMethodCall) -> Expr

Performs the conversion.

impl From<ExprParen> for Expr

fn from(e: ExprParen) -> Expr

Performs the conversion.

impl From<ExprPath> for Expr

fn from(e: ExprPath) -> Expr

Performs the conversion.

impl From<ExprRange> for Expr

fn from(e: ExprRange) -> Expr

Performs the conversion.

impl From<ExprReference> for Expr

fn from(e: ExprReference) -> Expr

Performs the conversion.

impl From<ExprRepeat> for Expr

fn from(e: ExprRepeat) -> Expr

Performs the conversion.

impl From<ExprReturn> for Expr

fn from(e: ExprReturn) -> Expr

Performs the conversion.

impl From<ExprStruct> for Expr

fn from(e: ExprStruct) -> Expr

Performs the conversion.

impl From<ExprTry> for Expr

fn from(e: ExprTry) -> Expr

Performs the conversion.

impl From<ExprTryBlock> for Expr

fn from(e: ExprTryBlock) -> Expr

Performs the conversion.

impl From<ExprTuple> for Expr

fn from(e: ExprTuple) -> Expr

Performs the conversion.

impl From<ExprType> for Expr

fn from(e: ExprType) -> Expr

Performs the conversion.

impl From<ExprUnary> for Expr

fn from(e: ExprUnary) -> Expr

Performs the conversion.

impl From<ExprUnsafe> for Expr

fn from(e: ExprUnsafe) -> Expr

Performs the conversion.

impl From<ExprWhile> for Expr

fn from(e: ExprWhile) -> Expr

Performs the conversion.

impl From<ExprYield> for Expr

fn from(e: ExprYield) -> Expr

Performs the conversion.

impl Hash for Expr

fn hash<H>(&self, hash: &mut H) where
    H: Hasher, 

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl Parse for Expr

fn parse(input: ParseStream) -> Result<Self>

impl PartialEq<Expr> for Expr

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl ToTokens for Expr

fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

Convert self directly into a TokenStream object.