Enum ExprKind

pub enum ExprKind {
    Var {
        name: Ident,
    },
    All {
        param: Ident,
        typ: Box<Expr>,
        body: Box<Expr>,
        erased: bool,
    },
    Lambda {
        param: Ident,
        body: Box<Expr>,
        erased: bool,
    },
    App {
        fun: Box<Expr>,
        args: Vec<AppBinding>,
    },
    Fun {
        name: QualifiedIdent,
        args: Spine,
    },
    Ctr {
        name: QualifiedIdent,
        args: Spine,
    },
    Let {
        name: Ident,
        val: Box<Expr>,
        next: Box<Expr>,
    },
    Ann {
        expr: Box<Expr>,
        typ: Box<Expr>,
    },
    Sub {
        name: Ident,
        indx: usize,
        redx: usize,
        expr: Box<Expr>,
    },
    Typ,
    NumTypeU60,
    NumTypeF60,
    NumU60 {
        numb: u64,
    },
    NumF60 {
        numb: u64,
    },
    Str {
        val: String,
    },
    Binary {
        op: Operator,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Hole {
        num: u64,
    },
    Hlp(Ident),
    Err,
}

Variants

Var

Name of a variable

Fields

name: Ident

All

The dependent function space (e.g. (x : Int) -> y)

Fields

param: Ident

typ: Box<Expr>

body: Box<Expr>

erased: bool

Lambda

A anonymous function that receives one argument

Fields

param: Ident

body: Box<Expr>

erased: bool

App

Application of a expression to a spine of expressions

Fields

fun: Box<Expr>

args: Vec<AppBinding>

Fun

Application of a function

Fields

name: QualifiedIdent

args: Spine

Ctr

Application of a Construtor

Fields

name: QualifiedIdent

args: Spine

Let

Declaration of a local variable

Fields

name: Ident

val: Box<Expr>

next: Box<Expr>

Ann

Type ascription (x : y)

Fields

expr: Box<Expr>

typ: Box<Expr>

Sub

Substitution

Fields

name: Ident

indx: usize

redx: usize

expr: Box<Expr>

Typ

Type Literal

NumTypeU60

60 bit integer type

NumTypeF60

60 bit floating point number type

NumU60

60 bit integer

Fields

numb: u64

NumF60

60 bit floating point number

Fields

numb: u64

Str

Very special constructor :)

Fields

val: String

Binary

Binary operation (e.g. 2 + 3)

Fields

op: Operator

left: Box<Expr>

right: Box<Expr>

Hole

A expression open to unification (e.g. _)

Fields

num: u64

Hlp(Ident)

Help

Err

Error node (It’s useful as a sentinel value to be able to continue compilation even with parts of the tree with problems)

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a duplicate of the value.

const 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 Hash for ExprKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ExprKind

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

Tests for self and other values to be equal, and is used by ==.

const 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 Eq for ExprKind

impl StructuralPartialEq for ExprKind