Enum ExprKind 

pub enum ExprKind {
    Int(Integer),
    Float(f64),
    Percent(f64),
    Dice {
        count: u32,
        sides: u32,
    },
    Str(Vec<StrSegment>),
    Bool(bool),
    Name(String),
    List(Vec<Expr>),
    Map(Vec<(Expr, Expr)>),
    Record {
        name: Option<Ident>,
        fields: Vec<Field>,
    },
    Unary {
        op: UnOp,
        expr: Box<Expr>,
    },
    Draw(Box<Expr>),
    Binary {
        op: BinOp,
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Call {
        callee: Box<Expr>,
        args: Vec<Arg>,
    },
    Method {
        receiver: Box<Expr>,
        name: Ident,
        args: Vec<Arg>,
    },
    Field {
        expr: Box<Expr>,
        name: Ident,
    },
    Index {
        expr: Box<Expr>,
        index: Box<Expr>,
    },
    With {
        expr: Box<Expr>,
        fields: Vec<Field>,
    },
    Lambda {
        params: Vec<Ident>,
        body: Box<Expr>,
    },
    If {
        cond: Box<Expr>,
        then: Block,
        otherwise: Option<Box<Expr>>,
    },
    Chance {
        arms: Vec<ChanceArm>,
    },
    Match {
        scrutinee: Box<Expr>,
        arms: Vec<MatchArm>,
    },
    Simulate(Block),
    Block(Block),
    Try {
        body: Block,
        catches: Vec<Catch>,
    },
}

Variants

Int(Integer)

Float(f64)

Percent(f64)

Already divided by 100.

Dice

Fields

count: u32

sides: u32

Str(Vec<StrSegment>)

Bool(bool)

Name(String)

List(Vec<Expr>)

Map(Vec<(Expr, Expr)>)

Record

Fighter { hp: 12 } (named) or { won: true } (anonymous).

Fields

name: Option<Ident>

fields: Vec<Field>

Unary

Fields

op: UnOp

expr: Box<Expr>

Draw(Box<Expr>)

Prefix ~: draw one value each time this expression is evaluated.

Binary

Fields

op: BinOp

lhs: Box<Expr>

rhs: Box<Expr>

Call

Fields

callee: Box<Expr>

args: Vec<Arg>

Method

receiver.name(args).

Fields

receiver: Box<Expr>

name: Ident

args: Vec<Arg>

Field

Fields

expr: Box<Expr>

name: Ident

Index

Fields

expr: Box<Expr>

index: Box<Expr>

With

expr with { field: value }.

Fields

expr: Box<Expr>

fields: Vec<Field>

Lambda

Fields

params: Vec<Ident>

body: Box<Expr>

If

Fields

cond: Box<Expr>

then: Block

otherwise: Option<Box<Expr>>

Chance

Fields

arms: Vec<ChanceArm>

Match

Fields

scrutinee: Box<Expr>

arms: Vec<MatchArm>

Simulate(Block)

Block(Block)

Try

try { … } catch Fault { … } catch { … }.

Fields

body: Block

catches: Vec<Catch>

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