Enum syn::Expr
[−]
[src]
pub enum Expr { Box(ExprBox), InPlace(ExprInPlace), Array(ExprArray), Call(ExprCall), MethodCall(ExprMethodCall), Tuple(ExprTuple), Binary(ExprBinary), Unary(ExprUnary), Lit(ExprLit), Cast(ExprCast), Type(ExprType), If(ExprIf), IfLet(ExprIfLet), While(ExprWhile), WhileLet(ExprWhileLet), ForLoop(ExprForLoop), Loop(ExprLoop), Match(ExprMatch), Closure(ExprClosure), Unsafe(ExprUnsafe), Block(ExprBlock), Assign(ExprAssign), AssignOp(ExprAssignOp), Field(ExprField), Index(ExprIndex), Range(ExprRange), Path(ExprPath), Reference(ExprReference), Break(ExprBreak), Continue(ExprContinue), Return(ExprReturn), Macro(ExprMacro), Struct(ExprStruct), Repeat(ExprRepeat), Paren(ExprParen), Group(ExprGroup), Try(ExprTry), Catch(ExprCatch), Yield(ExprYield), Verbatim(ExprVerbatim), }
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::IfLet(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 IfLet
case we
get to use expr.pat
, expr.then_branch
, expr.else_branch
.
The pattern is similar if the input expression is borrowed:
match *expr { Expr::MethodCall(ref expr) => {
This approach avoids repeating the variant names twice on every line.
Expr::MethodCall(ExprMethodCall { method, args, .. }) => { // repetitive
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(ref 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
Box(ExprBox)
A box expression: box f
.
This type is available if Syn is built with the "full"
feature.
InPlace(ExprInPlace)
A placement expression: place <- value
.
This type is available if Syn is built with the "full"
feature.
Array(ExprArray)
A slice literal expression: [a, b, c, d]
.
This type is available if Syn is built with the "full"
feature.
Call(ExprCall)
A function call expression: invoke(a, b)
.
This type is available if Syn is built with the "derive"
or
"full"
feature.
MethodCall(ExprMethodCall)
A method call expression: x.foo::<T>(a, b)
.
This type is available if Syn is built with the "full"
feature.
Tuple(ExprTuple)
A tuple expression: (a, b, c, d)
.
This type is available if Syn is built with the "full"
feature.
Binary(ExprBinary)
A binary operation: a + b
, a * b
.
This type is available if Syn is built with the "derive"
or
"full"
feature.
Unary(ExprUnary)
A unary operation: !x
, *x
.
This type is available if Syn is built with the "derive"
or
"full"
feature.
Lit(ExprLit)
A literal in place of an expression: 1
, "foo"
.
This type is available if Syn is built with the "derive"
or
"full"
feature.
Cast(ExprCast)
A cast expression: foo as f64
.
This type is available if Syn is built with the "derive"
or
"full"
feature.
Type(ExprType)
A type ascription expression: foo: f64
.
This type is available if Syn is built with the "full"
feature.
If(ExprIf)
An if
expression with an optional else
block: if expr { ... } else { ... }
.
The else
branch expression may only be an If
, IfLet
, or
Block
expression, not any of the other types of expression.
This type is available if Syn is built with the "full"
feature.
IfLet(ExprIfLet)
An if let
expression with an optional else
block: if let pat = expr { ... } else { ... }
.
The else
branch expression may only be an If
, IfLet
, or
Block
expression, not any of the other types of expression.
This type is available if Syn is built with the "full"
feature.
While(ExprWhile)
A while loop: while expr { ... }
.
This type is available if Syn is built with the "full"
feature.
WhileLet(ExprWhileLet)
A while-let loop: while let pat = expr { ... }
.
This type is available if Syn is built with the "full"
feature.
ForLoop(ExprForLoop)
A for loop: for pat in expr { ... }
.
This type is available if Syn is built with the "full"
feature.
Loop(ExprLoop)
Conditionless loop: loop { ... }
.
This type is available if Syn is built with the "full"
feature.
Match(ExprMatch)
A match
expression: match n { Some(n) => {}, None => {} }
.
This type is available if Syn is built with the "full"
feature.
Closure(ExprClosure)
A closure expression: |a, b| a + b
.
This type is available if Syn is built with the "full"
feature.
Unsafe(ExprUnsafe)
An unsafe block: unsafe { ... }
.
This type is available if Syn is built with the "full"
feature.
Block(ExprBlock)
A blocked scope: { ... }
.
This type is available if Syn is built with the "full"
feature.
Assign(ExprAssign)
An assignment expression: a = compute()
.
This type is available if Syn is built with the "full"
feature.
AssignOp(ExprAssignOp)
A compound assignment expression: counter += 1
.
This type is available if Syn is built with the "full"
feature.
Field(ExprField)
Access of a named struct field (obj.k
) or unnamed tuple struct
field (obj.0
).
This type is available if Syn is built with the "full"
feature.
Index(ExprIndex)
A square bracketed indexing expression: vector[2]
.
This type is available if Syn is built with the "derive"
or
"full"
feature.
Range(ExprRange)
A range expression: 1..2
, 1..
, ..2
, 1..=2
, ..=2
.
This type is available if Syn is built with the "full"
feature.
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.
This type is available if Syn is built with the "derive"
or
"full"
feature.
Reference(ExprReference)
A referencing operation: &a
or &mut a
.
This type is available if Syn is built with the "full"
feature.
Break(ExprBreak)
A break
, with an optional label to break and an optional
expression.
This type is available if Syn is built with the "full"
feature.
Continue(ExprContinue)
A continue
, with an optional label.
This type is available if Syn is built with the "full"
feature.
Return(ExprReturn)
A return
, with an optional value to be returned.
This type is available if Syn is built with the "full"
feature.
Macro(ExprMacro)
A macro invocation expression: format!("{}", q)
.
This type is available if Syn is built with the "full"
feature.
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 }
.
This type is available if Syn is built with the "full"
feature.
Repeat(ExprRepeat)
An array literal constructed from one repeated element: [0u8; N]
.
This type is available if Syn is built with the "full"
feature.
Paren(ExprParen)
A parenthesized expression: (a + b)
.
This type is available if Syn is built with the "full"
feature.
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
.
This type is available if Syn is built with the "full"
feature.
Try(ExprTry)
A try-expression: expr?
.
This type is available if Syn is built with the "full"
feature.
Catch(ExprCatch)
A catch expression: do catch { ... }
.
This type is available if Syn is built with the "full"
feature.
Yield(ExprYield)
A yield expression: yield expr
.
This type is available if Syn is built with the "full"
feature.
Verbatim(ExprVerbatim)
Tokens in expression position not interpreted by Syn.
This type is available if Syn is built with the "derive"
or
"full"
feature.
Trait Implementations
impl Synom for Expr
[src]
fn parse(i: Cursor) -> PResult<Self>
[src]
fn description() -> Option<&'static str>
[src]
A short name of the type being parsed. Read more
impl Debug for Expr
[src]
fn fmt(&self, __arg_0: &mut Formatter) -> Result
[src]
Formats the value using the given formatter. Read more
impl Eq for Expr
[src]
impl PartialEq for Expr
[src]
fn eq(&self, __arg_0: &Expr) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &Expr) -> bool
[src]
This method tests for !=
.
impl Hash for Expr
[src]
fn hash<__H: Hasher>(&self, __arg_0: &mut __H)
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl Clone for Expr
[src]
fn clone(&self) -> Expr
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl From<ExprBox> for Expr
[src]
impl From<ExprInPlace> for Expr
[src]
fn from(e: ExprInPlace) -> Expr
[src]
Performs the conversion.
impl From<ExprArray> for Expr
[src]
impl From<ExprCall> for Expr
[src]
impl From<ExprMethodCall> for Expr
[src]
fn from(e: ExprMethodCall) -> Expr
[src]
Performs the conversion.
impl From<ExprTuple> for Expr
[src]
impl From<ExprBinary> for Expr
[src]
fn from(e: ExprBinary) -> Expr
[src]
Performs the conversion.
impl From<ExprUnary> for Expr
[src]
impl From<ExprLit> for Expr
[src]
impl From<ExprCast> for Expr
[src]
impl From<ExprType> for Expr
[src]
impl From<ExprIf> for Expr
[src]
impl From<ExprIfLet> for Expr
[src]
impl From<ExprWhile> for Expr
[src]
impl From<ExprWhileLet> for Expr
[src]
fn from(e: ExprWhileLet) -> Expr
[src]
Performs the conversion.
impl From<ExprForLoop> for Expr
[src]
fn from(e: ExprForLoop) -> Expr
[src]
Performs the conversion.
impl From<ExprLoop> for Expr
[src]
impl From<ExprMatch> for Expr
[src]
impl From<ExprClosure> for Expr
[src]
fn from(e: ExprClosure) -> Expr
[src]
Performs the conversion.
impl From<ExprUnsafe> for Expr
[src]
fn from(e: ExprUnsafe) -> Expr
[src]
Performs the conversion.
impl From<ExprBlock> for Expr
[src]
impl From<ExprAssign> for Expr
[src]
fn from(e: ExprAssign) -> Expr
[src]
Performs the conversion.
impl From<ExprAssignOp> for Expr
[src]
fn from(e: ExprAssignOp) -> Expr
[src]
Performs the conversion.
impl From<ExprField> for Expr
[src]
impl From<ExprIndex> for Expr
[src]
impl From<ExprRange> for Expr
[src]
impl From<ExprPath> for Expr
[src]
impl From<ExprReference> for Expr
[src]
fn from(e: ExprReference) -> Expr
[src]
Performs the conversion.
impl From<ExprBreak> for Expr
[src]
impl From<ExprContinue> for Expr
[src]
fn from(e: ExprContinue) -> Expr
[src]
Performs the conversion.
impl From<ExprReturn> for Expr
[src]
fn from(e: ExprReturn) -> Expr
[src]
Performs the conversion.
impl From<ExprMacro> for Expr
[src]
impl From<ExprStruct> for Expr
[src]
fn from(e: ExprStruct) -> Expr
[src]
Performs the conversion.
impl From<ExprRepeat> for Expr
[src]
fn from(e: ExprRepeat) -> Expr
[src]
Performs the conversion.
impl From<ExprParen> for Expr
[src]
impl From<ExprGroup> for Expr
[src]
impl From<ExprTry> for Expr
[src]
impl From<ExprCatch> for Expr
[src]
impl From<ExprYield> for Expr
[src]
impl From<ExprVerbatim> for Expr
[src]
fn from(e: ExprVerbatim) -> Expr
[src]
Performs the conversion.
impl ToTokens for Expr
[src]
fn to_tokens(&self, tokens: &mut TokenStream)
[src]
Write self
to the given TokenStream
. Read more
fn into_token_stream(self) -> TokenStream
[src]
Convert self
directly into a TokenStream
object. Read more