Enum adapton::collection::Tree

pub enum Tree<A: Adapton, X, Lev> {
    Nil,
    Leaf(X),
    Bin(Lev, Box<Tree<A, X, Lev>>, Box<Tree<A, X, Lev>>),
    Name(A::Name, Lev, Box<Tree<A, X, Lev>>, Box<Tree<A, X, Lev>>),
    Rc(Rc<Tree<A, X, Lev>>),
    Art(Art<Tree<A, X, Lev>, A::Loc>),
}

Variants

NilLeaf(X)Bin(Lev, Box<Tree<A, X, Lev>>, Box<Tree<A, X, Lev>>)Name(A::Name, Lev, Box<Tree<A, X, Lev>>, Box<Tree<A, X, Lev>>)Rc(Rc<Tree<A, X, Lev>>)Art(Art<Tree<A, X, Lev>, A::Loc>)

Trait Implementations

impl<A: Clone + Adapton, X: Clone, Lev: Clone> Clone for Tree<A, X, Lev> where A::Name: Clone, A::Loc: Clone

fn clone(&self) -> Tree<A, X, Lev>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Hash + Adapton, X: Hash, Lev: Hash> Hash for Tree<A, X, Lev> where A::Name: Hash, A::Loc: Hash

fn hash<__HAXLev: Hasher>(&self, __arg_0: &mut __HAXLev)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl<A: Eq + Adapton, X: Eq, Lev: Eq> Eq for Tree<A, X, Lev> where A::Name: Eq, A::Loc: Eq

impl<A: PartialEq + Adapton, X: PartialEq, Lev: PartialEq> PartialEq for Tree<A, X, Lev> where A::Name: PartialEq, A::Loc: PartialEq

fn eq(&self, __arg_0: &Tree<A, X, Lev>) -> bool

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

fn ne(&self, __arg_0: &Tree<A, X, Lev>) -> bool

This method tests for !=.

impl<A: Debug + Adapton, X: Debug, Lev: Debug> Debug for Tree<A, X, Lev> where A::Name: Debug, A::Loc: Debug

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<A: Adapton + Debug + Hash + PartialEq + Eq + Clone, Leaf: Debug + Hash + PartialEq + Eq + Clone> TreeT<A, Leaf> for Tree<A, Leaf, u32>

type Tree = Tree<A, Leaf, Self::Lev>

type Lev = u32

fn lev<X: Hash>(x: &X) -> Self::Lev

fn lev_of_tree(st: &mut A, tree: &Self::Tree) -> Self::Lev

fn lev_bits() -> Self::Lev

fn lev_zero() -> Self::Lev

fn lev_max_val() -> Self::Lev

fn lev_add(x: &Self::Lev, y: &Self::Lev) -> Self::Lev

fn lev_inc(x: &Self::Lev) -> Self::Lev

fn lev_lte(x: &Self::Lev, y: &Self::Lev) -> bool

fn nil(_: &mut A) -> Self::Tree

fn leaf(_: &mut A, x: Leaf) -> Self::Tree

fn bin(_: &mut A, lev: Self::Lev, l: Self::Tree, r: Self::Tree) -> Self::Tree

fn name(_: &mut A, nm: A::Name, lev: Self::Lev, l: Self::Tree, r: Self::Tree) -> Self::Tree

fn rc(_: &mut A, rc: Rc<Self::Tree>) -> Self::Tree

fn art(_: &mut A, art: Art<Self::Tree, A::Loc>) -> Self::Tree

fn elim_move<Arg, Res, NilC, LeafC, BinC, NameC>(st: &mut A, tree: Self::Tree, arg: Arg, nil: NilC, leaf: LeafC, bin: BinC, name: NameC) -> Res where NilC: FnOnce(&mut A, Arg) -> Res, LeafC: FnOnce(&mut A, Leaf, Arg) -> Res, BinC: FnOnce(&mut A, Self::Lev, Self::Tree, Self::Tree, Arg) -> Res, NameC: FnOnce(&mut A, A::Name, Self::Lev, Self::Tree, Self::Tree, Arg) -> Res

fn elim<Res, NilC, LeafC, BinC, NameC>(st: &mut A, tree: Self::Tree, nil: NilC, leaf: LeafC, bin: BinC, name: NameC) -> Res where NilC: FnOnce(&mut A) -> Res, LeafC: FnOnce(&mut A, Leaf) -> Res, BinC: FnOnce(&mut A, Self::Lev, Self::Tree, Self::Tree) -> Res, NameC: FnOnce(&mut A, A::Name, Self::Lev, Self::Tree, Self::Tree) -> Res

fn elim_ref<Res, NilC, LeafC, BinC, NameC>(st: &mut A, tree: &Self::Tree, nil: NilC, leaf: LeafC, bin: BinC, name: NameC) -> Res where NilC: FnOnce(&mut A) -> Res, LeafC: FnOnce(&mut A, &Leaf) -> Res, BinC: FnOnce(&mut A, &Self::Lev, &Self::Tree, &Self::Tree) -> Res, NameC: FnOnce(&mut A, &A::Name, &Self::Lev, &Self::Tree, &Self::Tree) -> Res

fn lev_max(a: &Self::Lev, b: &Self::Lev) -> Self::Lev

fn fold_lr<Res: Hash + Debug + Eq + Clone, LeafC, BinC, NameC>(st: &mut A, tree: Self::Tree, res: Res, leaf: &LeafC, bin: &BinC, name: &NameC) -> Res where LeafC: Fn(&mut A, Leaf, Res) -> Res, BinC: Fn(&mut A, Self::Lev, Res) -> Res, NameC: Fn(&mut A, A::Name, Self::Lev, Res) -> Res

fn fold_rl<Res: Hash + Debug + Eq + Clone, LeafC, BinC, NameC>(st: &mut A, tree: Self::Tree, res: Res, leaf: &LeafC, bin: &BinC, name: &NameC) -> Res where LeafC: Fn(&mut A, Leaf, Res) -> Res, BinC: Fn(&mut A, Self::Lev, Res) -> Res, NameC: Fn(&mut A, A::Name, Self::Lev, Res) -> Res

fn fold_up<Res: Hash + Debug + Eq + Clone, NilC, LeafC, BinC, NameC>(st: &mut A, tree: Self::Tree, nil: &NilC, leaf: &LeafC, bin: &BinC, name: &NameC) -> Res where NilC: Fn(&mut A) -> Res, LeafC: Fn(&mut A, Leaf) -> Res, BinC: Fn(&mut A, Self::Lev, Res, Res) -> Res, NameC: Fn(&mut A, A::Name, Self::Lev, Res, Res) -> Res