Enum ExprKind 

pub enum ExprKind {
    Ident(Path),
    Lookup {
        base: Box<Expr>,
        lookup: Lookup,
    },
    Literal(Literal),
    Nested(Box<Expr>),
    TypeAnnotation(TypeAnnotation),
    Tuple(Vec<TupleField>),
    Array(Vec<Expr>),
    Variant(Variant),
    Range(Range),
    Binary(BinaryExpr),
    Unary(UnaryExpr),
    Call(Call),
    Func(Box<Func>),
    FuncShort(Box<FuncShort>),
    FString(Vec<InterpolateItem>),
    Match(Match),
    If(If),
    VarBinding(VarBinding),
}

Variants

Ident(Path)

Lookup

A lookup into an object by name or position. Currently, this includes only tuple field lookups, primarily by name.

Fields

base: Box<Expr>

lookup: Lookup

Literal(Literal)

Nested(Box<Expr>)

TypeAnnotation(TypeAnnotation)

Tuple(Vec<TupleField>)

Array(Vec<Expr>)

Variant(Variant)

Range(Range)

Binary(BinaryExpr)

Unary(UnaryExpr)

Call(Call)

Func(Box<Func>)

FuncShort(Box<FuncShort>)

FString(Vec<InterpolateItem>)

Match(Match)

If(If)

VarBinding(VarBinding)

Implementations

impl ExprKind

pub fn is_ident(&self) -> bool

Returns true if this is a ExprKind::Ident, otherwise false

pub fn as_ident_mut(&mut self) -> Option<&mut Path>

Optionally returns mutable references to the inner fields if this is a ExprKind::Ident, otherwise None

pub fn as_ident(&self) -> Option<&Path>

Optionally returns references to the inner fields if this is a ExprKind::Ident, otherwise None

pub fn into_ident(self) -> Result<Path, Self>

Returns the inner fields if this is a ExprKind::Ident, otherwise returns back the enum in the Err case of the result

pub fn is_lookup(&self) -> bool

Returns true if this is a ExprKind::Lookup, otherwise false

pub fn as_lookup_mut(&mut self) -> Option<(&mut Box<Expr>, &mut Lookup)>

Optionally returns mutable references to the inner fields if this is a ExprKind::Lookup, otherwise None

pub fn as_lookup(&self) -> Option<(&Box<Expr>, &Lookup)>

Optionally returns references to the inner fields if this is a ExprKind::Lookup, otherwise None

pub fn into_lookup(self) -> Result<(Box<Expr>, Lookup), Self>

Returns the inner fields if this is a ExprKind::Lookup, otherwise returns back the enum in the Err case of the result

pub fn is_literal(&self) -> bool

Returns true if this is a ExprKind::Literal, otherwise false

pub fn as_literal_mut(&mut self) -> Option<&mut Literal>

Optionally returns mutable references to the inner fields if this is a ExprKind::Literal, otherwise None

pub fn as_literal(&self) -> Option<&Literal>

Optionally returns references to the inner fields if this is a ExprKind::Literal, otherwise None

pub fn into_literal(self) -> Result<Literal, Self>

Returns the inner fields if this is a ExprKind::Literal, otherwise returns back the enum in the Err case of the result

pub fn is_nested(&self) -> bool

Returns true if this is a ExprKind::Nested, otherwise false

pub fn as_nested_mut(&mut self) -> Option<&mut Box<Expr>>

Optionally returns mutable references to the inner fields if this is a ExprKind::Nested, otherwise None

pub fn as_nested(&self) -> Option<&Box<Expr>>

Optionally returns references to the inner fields if this is a ExprKind::Nested, otherwise None

pub fn into_nested(self) -> Result<Box<Expr>, Self>

Returns the inner fields if this is a ExprKind::Nested, otherwise returns back the enum in the Err case of the result

pub fn is_type_annotation(&self) -> bool

Returns true if this is a ExprKind::TypeAnnotation, otherwise false

pub fn as_type_annotation_mut(&mut self) -> Option<&mut TypeAnnotation>

Optionally returns mutable references to the inner fields if this is a ExprKind::TypeAnnotation, otherwise None

pub fn as_type_annotation(&self) -> Option<&TypeAnnotation>

Optionally returns references to the inner fields if this is a ExprKind::TypeAnnotation, otherwise None

pub fn into_type_annotation(self) -> Result<TypeAnnotation, Self>

Returns the inner fields if this is a ExprKind::TypeAnnotation, otherwise returns back the enum in the Err case of the result

pub fn is_tuple(&self) -> bool

Returns true if this is a ExprKind::Tuple, otherwise false

pub fn as_tuple_mut(&mut self) -> Option<&mut Vec<TupleField>>

Optionally returns mutable references to the inner fields if this is a ExprKind::Tuple, otherwise None

pub fn as_tuple(&self) -> Option<&Vec<TupleField>>

Optionally returns references to the inner fields if this is a ExprKind::Tuple, otherwise None

pub fn into_tuple(self) -> Result<Vec<TupleField>, Self>

Returns the inner fields if this is a ExprKind::Tuple, otherwise returns back the enum in the Err case of the result

pub fn is_array(&self) -> bool

Returns true if this is a ExprKind::Array, otherwise false

pub fn as_array_mut(&mut self) -> Option<&mut Vec<Expr>>

Optionally returns mutable references to the inner fields if this is a ExprKind::Array, otherwise None

pub fn as_array(&self) -> Option<&Vec<Expr>>

Optionally returns references to the inner fields if this is a ExprKind::Array, otherwise None

pub fn into_array(self) -> Result<Vec<Expr>, Self>

Returns the inner fields if this is a ExprKind::Array, otherwise returns back the enum in the Err case of the result

pub fn is_variant(&self) -> bool

Returns true if this is a ExprKind::Variant, otherwise false

pub fn as_variant_mut(&mut self) -> Option<&mut Variant>

Optionally returns mutable references to the inner fields if this is a ExprKind::Variant, otherwise None

pub fn as_variant(&self) -> Option<&Variant>

Optionally returns references to the inner fields if this is a ExprKind::Variant, otherwise None

pub fn into_variant(self) -> Result<Variant, Self>

Returns the inner fields if this is a ExprKind::Variant, otherwise returns back the enum in the Err case of the result

pub fn is_range(&self) -> bool

Returns true if this is a ExprKind::Range, otherwise false

pub fn as_range_mut(&mut self) -> Option<&mut Range>

Optionally returns mutable references to the inner fields if this is a ExprKind::Range, otherwise None

pub fn as_range(&self) -> Option<&Range>

Optionally returns references to the inner fields if this is a ExprKind::Range, otherwise None

pub fn into_range(self) -> Result<Range, Self>

Returns the inner fields if this is a ExprKind::Range, otherwise returns back the enum in the Err case of the result

pub fn is_binary(&self) -> bool

Returns true if this is a ExprKind::Binary, otherwise false

pub fn as_binary_mut(&mut self) -> Option<&mut BinaryExpr>

Optionally returns mutable references to the inner fields if this is a ExprKind::Binary, otherwise None

pub fn as_binary(&self) -> Option<&BinaryExpr>

Optionally returns references to the inner fields if this is a ExprKind::Binary, otherwise None

pub fn into_binary(self) -> Result<BinaryExpr, Self>

Returns the inner fields if this is a ExprKind::Binary, otherwise returns back the enum in the Err case of the result

pub fn is_unary(&self) -> bool

Returns true if this is a ExprKind::Unary, otherwise false

pub fn as_unary_mut(&mut self) -> Option<&mut UnaryExpr>

Optionally returns mutable references to the inner fields if this is a ExprKind::Unary, otherwise None

pub fn as_unary(&self) -> Option<&UnaryExpr>

Optionally returns references to the inner fields if this is a ExprKind::Unary, otherwise None

pub fn into_unary(self) -> Result<UnaryExpr, Self>

Returns the inner fields if this is a ExprKind::Unary, otherwise returns back the enum in the Err case of the result

pub fn is_call(&self) -> bool

Returns true if this is a ExprKind::Call, otherwise false

pub fn as_call_mut(&mut self) -> Option<&mut Call>

Optionally returns mutable references to the inner fields if this is a ExprKind::Call, otherwise None

pub fn as_call(&self) -> Option<&Call>

Optionally returns references to the inner fields if this is a ExprKind::Call, otherwise None

pub fn into_call(self) -> Result<Call, Self>

Returns the inner fields if this is a ExprKind::Call, otherwise returns back the enum in the Err case of the result

pub fn is_func(&self) -> bool

Returns true if this is a ExprKind::Func, otherwise false

pub fn as_func_mut(&mut self) -> Option<&mut Box<Func>>

Optionally returns mutable references to the inner fields if this is a ExprKind::Func, otherwise None

pub fn as_func(&self) -> Option<&Box<Func>>

Optionally returns references to the inner fields if this is a ExprKind::Func, otherwise None

pub fn into_func(self) -> Result<Box<Func>, Self>

Returns the inner fields if this is a ExprKind::Func, otherwise returns back the enum in the Err case of the result

pub fn is_func_short(&self) -> bool

Returns true if this is a ExprKind::FuncShort, otherwise false

pub fn as_func_short_mut(&mut self) -> Option<&mut Box<FuncShort>>

Optionally returns mutable references to the inner fields if this is a ExprKind::FuncShort, otherwise None

pub fn as_func_short(&self) -> Option<&Box<FuncShort>>

Optionally returns references to the inner fields if this is a ExprKind::FuncShort, otherwise None

pub fn into_func_short(self) -> Result<Box<FuncShort>, Self>

Returns the inner fields if this is a ExprKind::FuncShort, otherwise returns back the enum in the Err case of the result

pub fn is_f_string(&self) -> bool

Returns true if this is a ExprKind::FString, otherwise false

pub fn as_f_string_mut(&mut self) -> Option<&mut Vec<InterpolateItem>>

Optionally returns mutable references to the inner fields if this is a ExprKind::FString, otherwise None

pub fn as_f_string(&self) -> Option<&Vec<InterpolateItem>>

Optionally returns references to the inner fields if this is a ExprKind::FString, otherwise None

pub fn into_f_string(self) -> Result<Vec<InterpolateItem>, Self>

Returns the inner fields if this is a ExprKind::FString, otherwise returns back the enum in the Err case of the result

pub fn is_match(&self) -> bool

Returns true if this is a ExprKind::Match, otherwise false

pub fn as_match_mut(&mut self) -> Option<&mut Match>

Optionally returns mutable references to the inner fields if this is a ExprKind::Match, otherwise None

pub fn as_match(&self) -> Option<&Match>

Optionally returns references to the inner fields if this is a ExprKind::Match, otherwise None

pub fn into_match(self) -> Result<Match, Self>

Returns the inner fields if this is a ExprKind::Match, otherwise returns back the enum in the Err case of the result

pub fn is_if(&self) -> bool

Returns true if this is a ExprKind::If, otherwise false

pub fn as_if_mut(&mut self) -> Option<&mut If>

Optionally returns mutable references to the inner fields if this is a ExprKind::If, otherwise None

pub fn as_if(&self) -> Option<&If>

Optionally returns references to the inner fields if this is a ExprKind::If, otherwise None

pub fn into_if(self) -> Result<If, Self>

Returns the inner fields if this is a ExprKind::If, otherwise returns back the enum in the Err case of the result

pub fn is_var_binding(&self) -> bool

Returns true if this is a ExprKind::VarBinding, otherwise false

pub fn as_var_binding_mut(&mut self) -> Option<&mut VarBinding>

Optionally returns mutable references to the inner fields if this is a ExprKind::VarBinding, otherwise None

pub fn as_var_binding(&self) -> Option<&VarBinding>

Optionally returns references to the inner fields if this is a ExprKind::VarBinding, otherwise None

pub fn into_var_binding(self) -> Result<VarBinding, Self>

Returns the inner fields if this is a ExprKind::VarBinding, otherwise returns back the enum in the Err case of the result

Trait Implementations

impl AsRef<str> for ExprKind

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl From<Func> for ExprKind

fn from(value: Func) -> Self

Converts to this type from the input type.

impl From<Literal> for ExprKind

fn from(value: Literal) -> Self

Converts to this type from the input type.

impl From<Path> for ExprKind

fn from(value: Path) -> Self

Converts to this type from the input type.

impl From<Range> for ExprKind

fn from(value: Range) -> Self

Converts to this type from the input type.

impl From<TypeAnnotation> for ExprKind

fn from(value: TypeAnnotation) -> Self

Converts to this type from the input type.

impl From<Variant> for ExprKind

fn from(value: Variant) -> Self

Converts to this type from the input type.

impl PartialEq for ExprKind

fn eq(&self, other: &ExprKind) -> 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 StructuralPartialEq for ExprKind