Enum Term 

pub enum Term {
    Literal(Datum),
    Ref(Ref),
    Local(Symbol),
    Let {
        name: Symbol,
        value: Box<Term>,
        body: Box<Term>,
    },
    Op {
        op: OpKey,
        input: Box<Term>,
    },
    Call {
        target: Box<Term>,
        args: Vec<Term>,
    },
    Seq(Vec<Term>),
    Quote {
        mode: QuoteMode,
        datum: Datum,
    },
    Annotated {
        term: Box<Term>,
        annotations: Vec<(Symbol, Datum)>,
    },
    Extension {
        tag: Symbol,
        payload: Datum,
    },
}

Lowered executable form.

Current Expr values lower as follows:

• scalar data -> Term::Literal
• Expr::Symbol -> Term::Ref(Ref::Symbol)
• Expr::Local -> Term::Local
• data-only list, vector, map, and set -> Term::Literal
• call -> Term::Call
• infix, prefix, and postfix -> Term::Call with a symbolic target
• block -> Term::Seq
• quote -> Term::Quote over pure Datum
• annotated -> Term::Annotated with datum annotations
• extension -> Term::Extension with a datum payload

Variants

Literal(Datum)

A constant datum value.

Ref(Ref)

A reference resolved through the registry or substrate.

Local(Symbol)

A lexical local binding referenced by name.

Let

A local binding form: bind name to value within body.

Fields

name: Symbol

The bound name.

value: Box<Term>

The term producing the bound value.

body: Box<Term>

The body evaluated with the binding in scope.

Op

An explicit operation invocation over one input term.

Fields

op: OpKey

The operation key naming the op.

input: Box<Term>

The input term the op consumes.

Call

A call of target with positional args.

Fields

target: Box<Term>

The term producing the callable target.

args: Vec<Term>

The positional argument terms.

Seq(Vec<Term>)

A sequence of terms evaluated in order.

Quote

A quoted datum carried at a given quote mode.

Fields

mode: QuoteMode

The quote mode (quote, quasiquote, …).

datum: Datum

The quoted datum.

Annotated

A term carrying datum-valued annotations.

Fields

term: Box<Term>

The annotated inner term.

annotations: Vec<(Symbol, Datum)>

The name/datum annotation pairs.

Extension

An open extension term with a tag and datum payload.

Fields

tag: Symbol

The extension tag.

payload: Datum

The extension payload datum.

Implementations

impl Term

pub fn lower(expr: Expr) -> Result<Self>

Lowers a checked Expr into its executable Term form.

This walks the expression graph and produces the lowered representation described on Term; it fails when a sub-expression cannot become a pure Datum.

Trait Implementations

impl Clone for Term

fn clone(&self) -> Term

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Term

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

Formats the value using the given formatter.

impl Eq for Term

impl From<Term> for Expr

fn from(term: Term) -> Self

Converts to this type from the input type.

impl Hash for Term

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 Term

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

impl TryFrom<Expr> for Term

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Self>

Performs the conversion.