Enum IrExpr 

pub enum IrExpr {
    Var(String),
    Lit(IrLit),
    App {
        func: Box<IrExpr>,
        args: Vec<IrExpr>,
    },
    Let {
        name: String,
        ty: IrType,
        value: Box<IrExpr>,
        body: Box<IrExpr>,
    },
    Lambda {
        params: Vec<(String, IrType)>,
        body: Box<IrExpr>,
        captured: Vec<String>,
    },
    If {
        cond: Box<IrExpr>,
        then_branch: Box<IrExpr>,
        else_branch: Box<IrExpr>,
    },
    Match {
        scrutinee: Box<IrExpr>,
        arms: Vec<IrMatchArm>,
    },
    Struct {
        name: String,
        fields: Vec<(String, IrExpr)>,
    },
    Field {
        object: Box<IrExpr>,
        field: String,
    },
    Alloc(Box<IrExpr>),
    Deref(Box<IrExpr>),
    Seq(Vec<IrExpr>),
}

Core intermediate representation expression

Variants

Var(String)

Variable reference

Lit(IrLit)

Literal value

App

Function application

Fields

func: Box<IrExpr>

args: Vec<IrExpr>

Let

Let binding

Fields

name: String

ty: IrType

value: Box<IrExpr>

body: Box<IrExpr>

Lambda

Lambda abstraction (after closure conversion, becomes function reference)

Fields

params: Vec<(String, IrType)>

body: Box<IrExpr>

captured: Vec<String>

If

Conditional expression

Fields

cond: Box<IrExpr>

then_branch: Box<IrExpr>

else_branch: Box<IrExpr>

Match

Pattern match

Fields

scrutinee: Box<IrExpr>

arms: Vec<IrMatchArm>

Struct

Struct construction

Fields

name: String

fields: Vec<(String, IrExpr)>

Field

Field access

Fields

object: Box<IrExpr>

field: String

Alloc(Box<IrExpr>)

Memory allocation

Deref(Box<IrExpr>)

Memory dereference

Seq(Vec<IrExpr>)

Sequence of expressions

Trait Implementations

impl Clone for IrExpr

fn clone(&self) -> IrExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IrExpr

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

Formats the value using the given formatter.

impl PartialEq for IrExpr

fn eq(&self, other: &IrExpr) -> 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 StructuralPartialEq for IrExpr