Enum bend::hvm::ast::Tree

pub enum Tree {
    Era,
    Num {
        val: u32,
    },
    Ref {
        nam: String,
    },
    Ctr {
        lab: u16,
        ports: Vec<Tree>,
    },
    Op {
        fst: Box<Tree>,
        snd: Box<Tree>,
    },
    Mat {
        zero: Box<Tree>,
        succ: Box<Tree>,
        out: Box<Tree>,
    },
    Var {
        nam: String,
    },
}

An AST node representing an interaction net tree.

Trees in interaction nets are inductively defined as either wires, or an agent with all of its auxiliary ports (if any) connected to trees.

Here, the wires at the leaves of the tree are represented with Tree::Var, where the variable name is shared between both sides of the wire.

Variants

Era

A nilary eraser node.

Num

A native 60-bit integer.

Fields

val: u32

Ref

A nilary node, referencing a named net.

Fields

nam: String

Ctr

A n-ary interaction combinator.

Fields

lab: u16

The label of the combinator. (Combinators with the same label annihilate, and combinators with different labels commute.)

ports: Vec<Tree>

The auxiliary ports of this node.

• 0 ports: this behaves identically to an eraser node.
• 1 port: this behaves identically to a wire.
• 2 ports: this is a standard binary combinator node.
• 3+ ports: equivalent to right-chained binary nodes; (a b c) is equivalent to (a (b c)).

The length of this vector must be less than MAX_ARITY.

Op

A binary node representing an operation on native integers.

The principal port connects to the left operand.

Fields

fst: Box<Tree>

An auxiliary port; connects to the right operand.

snd: Box<Tree>

An auxiliary port; connects to the output.

Mat

A binary node representing a match on native integers.

The principal port connects to the integer to be matched on.

Fields

zero: Box<Tree>

An auxiliary port; connects to the zero branch.

succ: Box<Tree>

An auxiliary port; connects to the a CTR with label 0 containing the predecessor and the output of the succ branch.

out: Box<Tree>

An auxiliary port; connects to the output.

Var

One side of a wire; the other side will have the same name.

Fields

nam: String

Implementations

impl Tree

pub fn children( &self ) -> impl ExactSizeIterator + DoubleEndedIterator<Item = &Tree>

pub fn children_mut( &mut self ) -> impl ExactSizeIterator + DoubleEndedIterator<Item = &mut Tree>

pub fn legacy_mat(arms: Tree, out: Tree) -> Option<Tree>

Trait Implementations

impl Clone for Tree

fn clone(&self) -> Tree

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tree

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

Formats the value using the given formatter.

impl Default for Tree

fn default() -> Tree

Returns the “default value” for a type.

impl Display for Tree

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

Formats the value using the given formatter.

impl Drop for Tree

fn drop(&mut self)

Executes the destructor for this type.

impl FromStr for Tree

type Err = String

The associated error which can be returned from parsing.

fn from_str(str: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Tree

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 Tree

fn eq(&self, other: &Tree) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Tree

impl StructuralPartialEq for Tree