Enum ExprKind 

pub enum ExprKind {
    Literal(Literal),
    Identifier(String),
    Call {
        callee: Box<Expr>,
        arguments: Vec<Expr>,
    },
    FieldAccess {
        base: Box<Expr>,
        field: String,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expr>,
    },
    Binary {
        op: BinaryOp,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Conditional {
        condition: Box<Expr>,
        when_true: Box<Expr>,
        when_false: Box<Expr>,
    },
    Assignment {
        op: AssignmentOp,
        left: Box<Expr>,
        right: Box<Expr>,
    },
}

One expression shape.

Variants

Literal(Literal)

One literal constant.

Identifier(String)

One variable or named constant reference.

Call

One function call or action invocation.

Fields

callee: Box<Expr>

Called expression.

arguments: Vec<Expr>

Call arguments in source order.

FieldAccess

One structure field access.

Fields

base: Box<Expr>

Expression on the left-hand side of ..

field: String

Field name on the right-hand side of ..

Unary

One unary or postfix operator.

Fields

op: UnaryOp

Applied operator.

expr: Box<Expr>

Operand expression.

Binary

One binary operator.

Fields

op: BinaryOp

Applied operator.

left: Box<Expr>

Left-hand operand.

right: Box<Expr>

Right-hand operand.

Conditional

One conditional expression.

Fields

condition: Box<Expr>

Condition before ?.

when_true: Box<Expr>

Expression between ? and :.

when_false: Box<Expr>

Expression after :.

Assignment

One assignment expression.

Fields

op: AssignmentOp

Applied assignment operator.

left: Box<Expr>

Assigned lvalue expression.

right: Box<Expr>

Right-hand expression.

Trait Implementations

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<'de> Deserialize<'de> for ExprKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 Serialize for ExprKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExprKind