Enum ExprKind 

pub enum ExprKind {
    Int(i64),
    Float(f64),
    Unit {
        value: String,
        unit: String,
    },
    Str(Vec<StrSeg>),
    RawStr(String),
    Text(String),
    Content {
        kind: String,
        id: String,
    },
    Tag(String),
    Bool(bool),
    None,
    Ident(String),
    SelfValue,
    It,
    Mc(VersionCond),
    Tuple(Vec<Expr>),
    List(Vec<Expr>),
    Map(Vec<(Expr, Expr)>),
    Lambda {
        params: Vec<Name>,
        body: Vec<Stmt>,
    },
    Unary {
        op: UnOp,
        expr: Box<Expr>,
    },
    Binary {
        op: BinOp,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Range {
        from: Box<Expr>,
        to: Box<Expr>,
        inclusive: bool,
    },
    Is {
        expr: Box<Expr>,
        ty: Type,
        bind: Option<Name>,
        negated: bool,
    },
    As {
        expr: Box<Expr>,
        ty: Type,
        checked: bool,
    },
    Call {
        callee: Box<Expr>,
        args: Vec<Arg>,
    },
    Index {
        expr: Box<Expr>,
        index: Box<Expr>,
    },
    TypeArgs {
        expr: Box<Expr>,
        args: Vec<Type>,
    },
    Member {
        expr: Box<Expr>,
        name: Name,
        safe: bool,
    },
    If {
        cond: Box<Cond>,
        then: Block,
        otherwise: Option<Box<Expr>>,
    },
    Match {
        expr: Box<Expr>,
        arms: Vec<Arm>,
    },
    Block(Block),
    Error,
}

Variants

Int(i64)

Float(f64)

Unit

Fields

value: String

unit: String

Str(Vec<StrSeg>)

RawStr(String)

Text(String)

Content

Fields

kind: String

id: String

Tag(String)

Bool(bool)

None

Ident(String)

SelfValue

It

Mc(VersionCond)

mc >= 1.21: the running game’s version.

Tuple(Vec<Expr>)

List(Vec<Expr>)

Map(Vec<(Expr, Expr)>)

Lambda

Fields

params: Vec<Name>

body: Vec<Stmt>

Unary

Fields

op: UnOp

expr: Box<Expr>

Binary

Fields

op: BinOp

left: Box<Expr>

right: Box<Expr>

Range

Fields

from: Box<Expr>

to: Box<Expr>

inclusive: bool

Is

x is T, x is T name, x !is T.

Fields

expr: Box<Expr>

ty: Type

bind: Option<Name>

negated: bool

As

x as T, x as? T.

Fields

expr: Box<Expr>

ty: Type

checked: bool

Call

Fields

callee: Box<Expr>

args: Vec<Arg>

Index

Fields

expr: Box<Expr>

index: Box<Expr>

TypeArgs

f<T, U> before a call: the type arguments.

Fields

expr: Box<Expr>

args: Vec<Type>

Member

x.name, x?.name.

Fields

expr: Box<Expr>

name: Name

safe: bool

If

Fields

cond: Box<Cond>

then: Block

otherwise: Option<Box<Expr>>

Match

Fields

expr: Box<Expr>

arms: Vec<Arm>

Block(Block)

Error

What couldn’t be parsed (reported already).

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> Self

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

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ExprKind