Enum Expr 

pub enum Expr {
    Nil,
    Bool(bool),
    Number(NumberLiteral),
    Symbol(Symbol),
    Local(Symbol),
    String(String),
    Bytes(Vec<u8>),
    List(Vec<Expr>),
    Vector(Vec<Expr>),
    Map(Vec<(Expr, Expr)>),
    Set(Vec<Expr>),
    Call {
        operator: Box<Expr>,
        args: Vec<Expr>,
    },
    Infix {
        operator: Symbol,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Prefix {
        operator: Symbol,
        arg: Box<Expr>,
    },
    Postfix {
        operator: Symbol,
        arg: Box<Expr>,
    },
    Block(Vec<Expr>),
    Quote {
        mode: QuoteMode,
        expr: Box<Expr>,
    },
    Annotated {
        expr: Box<Expr>,
        annotations: Vec<(Symbol, Expr)>,
    },
    Extension {
        tag: Symbol,
        payload: Box<Expr>,
    },
}

The codec-neutral expression graph: the checked form of source.

The kernel defines this graph; general-purpose codecs in library crates round-trip every expression through it. It is the checked forms stage of the data flow tokens -> checked forms -> objects -> checked calls -> objects -> encoded forms. Equality and hashing are canonical (see Expr::canonical_eq): map entries and set members compare order-insensitively.

Examples

let call = Expr::Call {
    operator: Box::new(Expr::Symbol(Symbol::new("add"))),
    args: vec![Expr::Bool(true), Expr::Nil],
};
// Maps compare canonically regardless of entry order.
let a = Expr::Set(vec![Expr::Bool(true), Expr::Nil]);
let b = Expr::Set(vec![Expr::Nil, Expr::Bool(true)]);
assert!(a.canonical_eq(&b));
let _ = call;

Variants

Nil

The nil literal.

Bool(bool)

A boolean literal.

Number(NumberLiteral)

A number literal in some domain.

Symbol(Symbol)

A symbol reference.

Local(Symbol)

A lexical local reference.

String(String)

A string literal.

Bytes(Vec<u8>)

A byte-string literal.

List(Vec<Expr>)

An ordered list form.

Vector(Vec<Expr>)

An ordered vector form.

Map(Vec<(Expr, Expr)>)

A map form of key/value pairs (order-insensitive when compared).

Set(Vec<Expr>)

A set form (order-insensitive when compared).

Call

A call of operator with positional args.

Fields

operator: Box<Expr>

The expression producing the callable operator.

args: Vec<Expr>

The positional argument expressions.

Infix

An infix operator application.

Fields

operator: Symbol

The operator symbol.

left: Box<Expr>

The left operand.

right: Box<Expr>

The right operand.

Prefix

A prefix operator application.

Fields

operator: Symbol

The operator symbol.

arg: Box<Expr>

The operand.

Postfix

A postfix operator application.

Fields

operator: Symbol

The operator symbol.

arg: Box<Expr>

The operand.

Block(Vec<Expr>)

A sequenced block of expressions.

Quote

A quoted expression carried at a given quote mode.

Fields

mode: QuoteMode

The quote mode (quote, quasiquote, …).

expr: Box<Expr>

The quoted expression.

Annotated

An expression carrying named annotations.

Fields

expr: Box<Expr>

The annotated inner expression.

annotations: Vec<(Symbol, Expr)>

The name/value annotation pairs.

Extension

An open extension form with a tag and payload.

Fields

tag: Symbol

The extension tag.

payload: Box<Expr>

The extension payload expression.

Implementations

impl Expr

pub fn canonical_key(&self) -> CanonicalKey

Computes the CanonicalKey backing canonical equality and hashing.

pub fn canonical_eq(&self, other: &Self) -> bool

Returns whether two expressions are canonically equal.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

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

Formats the value using the given formatter.

impl Eq for Expr

impl From<Datum> for Expr

fn from(datum: Datum) -> Self

Converts to this type from the input type.

impl From<Term> for Expr

fn from(term: Term) -> Self

Converts to this type from the input type.

impl Hash for Expr

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 Expr

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

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

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.