Enum Expr

pub enum Expr {
    Term {
        sym: Ident,
        args: Vec<Expr>,
        pos: Pos,
    },
    Var {
        name: Ident,
        pos: Pos,
    },
    ConstInt {
        val: i128,
        pos: Pos,
    },
    ConstPrim {
        val: Ident,
        pos: Pos,
    },
    Let {
        defs: Vec<LetDef>,
        body: Box<Expr>,
        pos: Pos,
    },
}

An expression: the right-hand side of a rule.

Note that this almost looks like a core Lisp or lambda calculus, except that there is no abstraction (lambda). This first-order limit is what makes it analyzable.

Variants

Term

A term: (sym args...).

Fields

sym: Ident

args: Vec<Expr>

pos: Pos

Var

A variable use.

Fields

name: Ident

pos: Pos

ConstInt

A constant integer.

Fields

val: i128

pos: Pos

ConstPrim

A constant of some other primitive type.

Fields

val: Ident

pos: Pos

Let

The (let ((var ty val)*) body) form.

Fields

defs: Vec<LetDef>

body: Box<Expr>

pos: Pos

Implementations

impl Expr

pub fn pos(&self) -> Pos

pub fn terms(&self, f: &mut dyn FnMut(Pos, &Ident))

Call f for each of the terms in this expression.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy 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.

impl PartialEq for Expr

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

impl StructuralPartialEq for Expr