Enum Expr

pub enum Expr<'a> {
    Path(Path<'a>),
    Scope(Scope<'a>),
    Sexpr(Sexpr<'a>),
    Lambda(Lambda<'a>),
    Pi(Pi<'a>),
    Phi(Phi<'a>),
    Gamma(Gamma<'a>),
    Bool(bool),
    BoolTy(Bool),
    LogicalOp(LogicalOp),
    Natural(Natural),
    Integer(Integer),
}

An AST node for a rain expression

Variants

Path(Path<'a>)

A path

Scope(Scope<'a>)

A scope

Sexpr(Sexpr<'a>)

An S-expression

Lambda(Lambda<'a>)

A lambda expression

Pi(Pi<'a>)

A pi type

Phi(Phi<'a>)

A phi node

Gamma(Gamma<'a>)

A gamma node

Bool(bool)

A boolean constant

BoolTy(Bool)

The boolean type

LogicalOp(LogicalOp)

A logical operation

Natural(Natural)

A natural number

Integer(Integer)

An integer

Implementations

impl<'a> Expr<'a>

pub fn ident<T>(ident: T) -> Expr<'a>

where T: Into<&'a str>,

Create a new path consisting of just an identifier

pub fn push<T>(self, other: T) -> Expr<'a>

where T: Into<Box<Expr<'a>>>,

Attempt to build an S-expression from this value, with the other value at the front. For example, 5 + 5 = (+ 5 5) can be written let sum = 5, sum.push(5), sum.push(+)

Trait Implementations

impl<'a> Clone for Expr<'a>

fn clone(&self) -> Expr<'a>

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, fmt: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for Expr<'_>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Expr<'a>

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

impl<'a> StructuralPartialEq for Expr<'a>