Enum Expr 

pub enum Expr {
    Int(i64, Span),
    Float(f64, Span),
    String(String, Span),
    FString(Vec<Expr>, Span),
    Bool(bool, Span),
    None(Span),
    Ident(String, Span),
    MacroCall {
        name: String,
        args: Vec<Expr>,
        span: Span,
    },
    Binary {
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
        span: Span,
    },
    Unary {
        op: UnaryOp,
        operand: Box<Expr>,
        span: Span,
    },
    Call {
        callee: Box<Expr>,
        args: Vec<CallArg>,
        span: Span,
    },
    MethodCall {
        receiver: Box<Expr>,
        method: String,
        args: Vec<CallArg>,
        span: Span,
    },
    Field {
        object: Box<Expr>,
        field: String,
        span: Span,
    },
    Index {
        object: Box<Expr>,
        index: Box<Expr>,
        span: Span,
    },
    Assign {
        target: Box<Expr>,
        value: Box<Expr>,
        span: Span,
    },
    Struct {
        name: String,
        fields: Vec<(String, Expr)>,
        span: Span,
    },
    EnumVariant {
        enum_name: String,
        variant: String,
        fields: EnumVariantFields,
        span: Span,
    },
    Array(Vec<Expr>, Span),
    Tuple(Vec<Expr>, Span),
    Range {
        start: Option<Box<Expr>>,
        end: Option<Box<Expr>>,
        inclusive: bool,
        span: Span,
    },
    If {
        condition: Box<Expr>,
        then_branch: Block,
        else_branch: Option<Box<ElseBranch>>,
        span: Span,
    },
    Match {
        scrutinee: Box<Expr>,
        arms: Vec<MatchArm>,
        span: Span,
    },
    Lambda {
        params: Vec<Param>,
        return_type: Option<Type>,
        body: Box<Expr>,
        span: Span,
    },
    Ref {
        mutable: bool,
        value: Box<Expr>,
        span: Span,
    },
    Deref(Box<Expr>, Span),
    Cast {
        value: Box<Expr>,
        target: Type,
        span: Span,
    },
    Try(Box<Expr>, Span),
    Await(Box<Expr>, Span),
    Spawn {
        actor: String,
        init: Vec<(String, Expr)>,
        span: Span,
    },
    SendMsg {
        target: Box<Expr>,
        message: String,
        data: Vec<(String, Expr)>,
        span: Span,
    },
    Comptime(Box<Expr>, Span),
    Block(Block, Span),
    JSX(JSXNode, Span),
    Paren(Box<Expr>, Span),
    Return(Option<Box<Expr>>, Span),
    Break(Option<Box<Expr>>, Span),
    Continue(Span),
}

Variants

Int(i64, Span)

Literals

Float(f64, Span)

String(String, Span)

FString(Vec<Expr>, Span)

Bool(bool, Span)

None(Span)

Ident(String, Span)

Identifier

MacroCall

Macro call

Fields

name: String

args: Vec<Expr>

span: Span

Binary

Binary operation

Fields

left: Box<Expr>

op: BinaryOp

right: Box<Expr>

span: Span

Unary

Unary operation

Fields

op: UnaryOp

operand: Box<Expr>

span: Span

Call

Function call: func(args)

Fields

callee: Box<Expr>

args: Vec<CallArg>

span: Span

MethodCall

Method call: obj.method(args)

Fields

receiver: Box<Expr>

method: String

args: Vec<CallArg>

span: Span

Field

Field access: obj.field

Fields

object: Box<Expr>

field: String

span: Span

Index

Index: arr[i]

Fields

object: Box<Expr>

index: Box<Expr>

span: Span

Assign

Assignment: target = value

Fields

target: Box<Expr>

value: Box<Expr>

span: Span

Struct

Struct literal: Point { x: 1, y: 2 }

Fields

name: String

fields: Vec<(String, Expr)>

span: Span

EnumVariant

Fields

enum_name: String

variant: String

fields: EnumVariantFields

span: Span

Array(Vec<Expr>, Span)

Array literal: [1, 2, 3]

Tuple(Vec<Expr>, Span)

Tuple literal: (a, b, c)

Range

Range: start..end, start..=end

Fields

start: Option<Box<Expr>>

end: Option<Box<Expr>>

inclusive: bool

span: Span

If

If expression

Fields

condition: Box<Expr>

then_branch: Block

else_branch: Option<Box<ElseBranch>>

span: Span

Match

Match expression

Fields

scrutinee: Box<Expr>

arms: Vec<MatchArm>

span: Span

Lambda

Lambda: |args| body or |args| -> Type: body

Fields

params: Vec<Param>

return_type: Option<Type>

body: Box<Expr>

span: Span

Ref

Reference: &value, &mut value

Fields

mutable: bool

value: Box<Expr>

span: Span

Deref(Box<Expr>, Span)

Dereference: *ptr

Cast

Cast: value as Type

Fields

value: Box<Expr>

target: Type

span: Span

Try(Box<Expr>, Span)

Try: expr?

Await(Box<Expr>, Span)

Await: await expr

Spawn

Spawn actor: spawn ActorName { state }

Fields

actor: String

init: Vec<(String, Expr)>

span: Span

SendMsg

Send message: send target <- Message { data }

Fields

target: Box<Expr>

message: String

data: Vec<(String, Expr)>

span: Span

Comptime(Box<Expr>, Span)

Comptime expression: comptime { expr }

Block(Block, Span)

Macro invocation: name!(args) Block expression

JSX(JSXNode, Span)

JSX embedded in expression

Paren(Box<Expr>, Span)

Grouped expression: (expr)

Return(Option<Box<Expr>>, Span)

Return expression: return [expr]

Break(Option<Box<Expr>>, Span)

Break expression: break [expr]

Continue(Span)

Continue expression: continue

Implementations

impl Expr

pub fn span(&self) -> Span

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.