Enum ExprKind 

pub enum ExprKind {
    Int(i64),
    Float(f64),
    Unit {
        value: String,
        unit: String,
    },
    Str(Vec<StrSeg>),
    RawStr(String),
    Char(char),
    Text(String),
    Content {
        kind: String,
        id: String,
    },
    Tag(String),
    Bool(bool),
    Null,
    Ident(String),
    This,
    Base,
    It,
    Declare {
        ty: Option<Type>,
        name: Name,
        mutable: bool,
    },
    TypeOf(Type),
    NameOf(Box<Expr>),
    Default(Option<Type>),
    Mc(VersionCond),
    Tuple(Vec<Expr>),
    Collection(Vec<Element>),
    New {
        ty: Option<Type>,
        args: Option<Vec<Arg>>,
        init: Vec<(Name, Expr)>,
    },
    Lambda {
        params: Vec<LambdaParam>,
        body: LambdaBody,
    },
    Unary {
        op: UnOp,
        expr: Box<Expr>,
    },
    Cast {
        ty: Type,
        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>,
        pattern: Box<Pattern>,
    },
    As {
        expr: Box<Expr>,
        ty: Type,
    },
    Has {
        expr: Box<Expr>,
        ty: Type,
    },
    Conditional {
        cond: Box<Expr>,
        then: Box<Expr>,
        otherwise: Box<Expr>,
    },
    Switch {
        expr: Box<Expr>,
        arms: Vec<Arm>,
    },
    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,
    },
    Macro {
        name: Name,
        args: Vec<Expr>,
    },
    Move(Box<Expr>),
    NotNull(Box<Expr>),
    Error,
}

Variants

Int(i64)

Float(f64)

Unit

Fields

value: String

unit: String

Str(Vec<StrSeg>)

RawStr(String)

Char(char)

Text(String)

Content

Fields

kind: String

id: String

Tag(String)

Bool(bool)

Null

Ident(String)

This

Base

base: this as its base class (base.Tick()).

It

Declare

out let x, out i32 x: a local declared where a method gives it.

Fields

ty: Option<Type>

name: Name

mutable: bool

TypeOf(Type)

typeof(T): its System.Type.

NameOf(Box<Expr>)

nameof(x.Y): its last name, as a string.

Default(Option<Type>)

default, default(T): the type’s zero value.

Mc(VersionCond)

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

Tuple(Vec<Expr>)

Collection(Vec<Element>)

[a, b], [k => v], [..xs]: a list, a set or a map by its target.

New

new Pos(1, 2, 3), new(4), new Battery { Count = 2 }.

Fields

ty: Option<Type>

args: Option<Vec<Arg>>

init: Vec<(Name, Expr)>

Lambda

x => …, (a, b) => …, { … } after a call (it its parameter).

Fields

params: Vec<LambdaParam>

body: LambdaBody

Unary

Fields

op: UnOp

expr: Box<Expr>

Cast

(i32)x.

Fields

ty: Type

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 Monster m, x is not null.

Fields

expr: Box<Expr>

pattern: Box<Pattern>

As

x as T: null when it isn’t one.

Fields

expr: Box<Expr>

ty: Type

Has

x has Charge.

Fields

expr: Box<Expr>

ty: Type

Conditional

c ? a : b.

Fields

cond: Box<Expr>

then: Box<Expr>

otherwise: Box<Expr>

Switch

x switch { … }.

Fields

expr: Box<Expr>

arms: Vec<Arm>

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

Macro

panic!(…): a built-in macro’s call (a declared macro’s is expanded before the parser sees it).

Fields

name: Name

args: Vec<Expr>

Move(Box<Expr>)

move x: x handed on, gone after.

NotNull(Box<Expr>)

x!: asserted not null.

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