Enum syn::Expr [−][src]
#[non_exhaustive]
pub enum Expr {
Show 40 variants
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),
}
Expand description
A Rust expression.
This type is available only if Syn is built with the "derive"
or "full"
feature, but most of the variants are not available unless “full” is enabled.
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 (Non-exhaustive)
This enum is marked as non-exhaustive
Array(ExprArray)
Tuple Fields
0: ExprArray
A slice literal expression: [a, b, c, d]
.
Assign(ExprAssign)
Tuple Fields
0: ExprAssign
An assignment expression: a = compute()
.
AssignOp(ExprAssignOp)
Tuple Fields
0: ExprAssignOp
A compound assignment expression: counter += 1
.
Async(ExprAsync)
Tuple Fields
0: ExprAsync
An async block: async { ... }
.
Await(ExprAwait)
Tuple Fields
0: ExprAwait
An await expression: fut.await
.
Binary(ExprBinary)
Tuple Fields
0: ExprBinary
A binary operation: a + b
, a * b
.
Block(ExprBlock)
Tuple Fields
0: ExprBlock
A blocked scope: { ... }
.
Box(ExprBox)
Tuple Fields
0: ExprBox
A box expression: box f
.
Break(ExprBreak)
Tuple Fields
0: ExprBreak
A break
, with an optional label to break and an optional
expression.
Call(ExprCall)
Tuple Fields
0: ExprCall
A function call expression: invoke(a, b)
.
Cast(ExprCast)
Tuple Fields
0: ExprCast
A cast expression: foo as f64
.
Closure(ExprClosure)
Tuple Fields
0: ExprClosure
A closure expression: |a, b| a + b
.
Continue(ExprContinue)
Tuple Fields
0: ExprContinue
A continue
, with an optional label.
Field(ExprField)
Tuple Fields
0: ExprField
Access of a named struct field (obj.k
) or unnamed tuple struct
field (obj.0
).
ForLoop(ExprForLoop)
Tuple Fields
0: ExprForLoop
A for loop: for pat in expr { ... }
.
Group(ExprGroup)
Tuple Fields
0: 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)
Tuple Fields
0: 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)
Tuple Fields
0: ExprIndex
A square bracketed indexing expression: vector[2]
.
Let(ExprLet)
Tuple Fields
0: ExprLet
A let
guard: let Some(x) = opt
.
Lit(ExprLit)
Tuple Fields
0: ExprLit
A literal in place of an expression: 1
, "foo"
.
Loop(ExprLoop)
Tuple Fields
0: ExprLoop
Conditionless loop: loop { ... }
.
Macro(ExprMacro)
Tuple Fields
0: ExprMacro
A macro invocation expression: format!("{}", q)
.
Match(ExprMatch)
Tuple Fields
0: ExprMatch
A match
expression: match n { Some(n) => {}, None => {} }
.
MethodCall(ExprMethodCall)
Tuple Fields
A method call expression: x.foo::<T>(a, b)
.
Paren(ExprParen)
Tuple Fields
0: ExprParen
A parenthesized expression: (a + b)
.
Path(ExprPath)
Tuple Fields
0: 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)
Tuple Fields
0: ExprRange
A range expression: 1..2
, 1..
, ..2
, 1..=2
, ..=2
.
Reference(ExprReference)
Tuple Fields
A referencing operation: &a
or &mut a
.
Repeat(ExprRepeat)
Tuple Fields
0: ExprRepeat
An array literal constructed from one repeated element: [0u8; N]
.
Return(ExprReturn)
Tuple Fields
0: ExprReturn
A return
, with an optional value to be returned.
Struct(ExprStruct)
Tuple Fields
0: 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)
Tuple Fields
0: ExprTry
A try-expression: expr?
.
TryBlock(ExprTryBlock)
Tuple Fields
0: ExprTryBlock
A try block: try { ... }
.
Tuple(ExprTuple)
Tuple Fields
0: ExprTuple
A tuple expression: (a, b, c, d)
.
Type(ExprType)
Tuple Fields
0: ExprType
A type ascription expression: foo: f64
.
Unary(ExprUnary)
Tuple Fields
0: ExprUnary
A unary operation: !x
, *x
.
Unsafe(ExprUnsafe)
Tuple Fields
0: ExprUnsafe
An unsafe block: unsafe { ... }
.
Verbatim(TokenStream)
Tuple Fields
0: TokenStream
Tokens in expression position not interpreted by Syn.
While(ExprWhile)
Tuple Fields
0: ExprWhile
A while loop: while expr { ... }
.
Yield(ExprYield)
Tuple Fields
0: ExprYield
A yield expression: yield expr
.
Trait Implementations
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Auto Trait Implementations
impl RefUnwindSafe for Expr
impl UnwindSafe for Expr
Blanket Implementations
Mutably borrows from an owned value. Read more