Enum ExprKind 

pub enum ExprKind {
    NumberLit(f64),
    StringLit(String),
    StringInterpolation(Vec<StringPart>),
    BoolLit(bool),
    NilLit,
    ListLit(Vec<Expr>),
    RecordLit(Vec<RecordEntry>),
    Identifier(String),
    Call {
        name: Ident,
        args: Vec<Expr>,
    },
    QualifiedCall {
        module: Ident,
        function: Ident,
        args: Vec<Expr>,
    },
    FieldAccess {
        object: Box<Expr>,
        field: Ident,
    },
    MethodCall {
        object: Box<Expr>,
        method: Ident,
        args: Vec<Expr>,
    },
    Binary {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    Unary {
        op: UnaryOp,
        operand: Box<Expr>,
    },
    ResultUnwrap(Box<Expr>),
    NilCoalesce {
        left: Box<Expr>,
        right: Box<Expr>,
    },
    If(Box<IfExpr>),
    For(Box<ForExpr>),
    Match(Box<MatchExpr>),
    Lambda(Box<LambdaExpr>),
    Paren(Box<Expr>),
}

The kind of expression.

Variants

NumberLit(f64)

42, 3.14

StringLit(String)

"hello" (no interpolation)

StringInterpolation(Vec<StringPart>)

"hello ${name}" — parts alternate: string, expr, string, expr, string

BoolLit(bool)

true / false

NilLit

nil

ListLit(Vec<Expr>)

[expr, ...]

RecordLit(Vec<RecordEntry>)

{ field: expr, ...spread, ... }

Identifier(String)

my_var, count

Call

func(args...) — unqualified call

Fields

name: Ident

args: Vec<Expr>

QualifiedCall

module.function(args...) — qualified (stdlib) call

Fields

module: Ident

function: Ident

args: Vec<Expr>

FieldAccess

expr.field

Fields

object: Box<Expr>

field: Ident

MethodCall

expr.method(args...)

Fields

object: Box<Expr>

method: Ident

args: Vec<Expr>

Binary

a + b, a == b, a and b, etc.

Fields

left: Box<Expr>

op: BinOp

right: Box<Expr>

Unary

-x, not x

Fields

op: UnaryOp

operand: Box<Expr>

ResultUnwrap(Box<Expr>)

expr? — Result unwrap

NilCoalesce

a ?? b — nil-coalescing

Fields

left: Box<Expr>

right: Box<Expr>

If(Box<IfExpr>)

if cond { ... } [else { ... }]

For(Box<ForExpr>)

for item [, index] in expr { ... }

Match(Box<MatchExpr>)

match expr { arms... }

Lambda(Box<LambdaExpr>)

fn(params) { body }

Paren(Box<Expr>)

(expr)

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