Struct Node 

pub struct Node {
    pub heads: &'static [(&'static str, usize, u32)],
    pub ints: &'static [(i128, u32)],
    pub same: &'static [(usize, u32)],
    pub wildcard: Option<(&'static str, u32)>,
    pub accept: Option<u32>,
}

One node of the trie over the patterns.

The branches are held by the kind of question they ask rather than in one list, which is what lets the two that can be searched be searched.

Fields

heads: &'static [(&'static str, usize, u32)]

The branches taken on the head of the subterm, as the name, how many arguments it takes, and where to go. Sorted by the first two, which is what Node::branch needs.

ints: &'static [(i128, u32)]

The branches taken on the value of a subterm that is a constant, sorted by the value.

same: &'static [(usize, u32)]

The branches taken when the subterm is the same thing as a binding this pattern already made, named by which binding it is. A pattern writes one where it writes a name for the second time, so this is how x & x is told apart from x & y. In the order the rules were written, because two of them can match one subterm.

wildcard: Option<(&'static str, u32)>

The branch that takes anything, and the name the first rule to reach it gave that hole.

accept: Option<u32>

The rule that ends here, if one does.

Implementations

impl Node

pub fn branch(&self, head: &str, arity: usize) -> Option<u32>

The branch for a term with this head and this many arguments, if the node has one.

A binary search, which is the whole point of the list being sorted. At most one branch can answer, so nothing about which rule fires depends on the list being in this order rather than in the order the rules were written.

pub fn literal(&self, value: i128) -> Option<u32>

The branch for a constant of this value, if the node has one.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Node

impl Debug for Node

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

Formats the value using the given formatter.