Enum ExprKind

pub enum ExprKind {
    Var {
        name: Ident,
    },
    Lambda {
        param: Ident,
        body: Box<Expr>,
        erased: bool,
    },
    App {
        fun: Box<Expr>,
        args: Vec<Box<Expr>>,
    },
    Fun {
        name: QualifiedIdent,
        args: Spine,
    },
    Ctr {
        name: QualifiedIdent,
        args: Spine,
    },
    Let {
        name: Ident,
        val: Box<Expr>,
        next: Box<Expr>,
    },
    U60 {
        numb: u64,
    },
    F60 {
        numb: u64,
    },
    Str {
        val: String,
    },
    Binary {
        op: Operator,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Err,
}

Variants

Var

Name of a variable

Fields

name: Ident

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<Box<Expr>>

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>

U60

60 bit unsigned integer

Fields

numb: u64

F60

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>

Err

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