Trait adapton::collection_traits::TreeT [−] [src]

pub trait TreeT<A: Adapton, Leaf> {
    type Lev: Debug + Hash + PartialEq + Eq + Clone;
    type Tree: Debug + Hash + PartialEq + Eq + Clone;
    fn lev<X: Hash>(&X) -> Self::Lev;
    fn lev_of_tree(&mut A, &Self::Tree) -> Self::Lev;
    fn lev_bits() -> Self::Lev;
    fn lev_zero() -> Self::Lev;
    fn lev_inc(&Self::Lev) -> Self::Lev;
    fn lev_add(&Self::Lev, &Self::Lev) -> Self::Lev;
    fn lev_lte(&Self::Lev, &Self::Lev) -> bool;
    fn lev_max_val() -> Self::Lev;
    fn nil(&mut A) -> Self::Tree;
    fn leaf(&mut A, Leaf) -> Self::Tree;
    fn bin(&mut A, Self::Lev, Self::Tree, Self::Tree) -> Self::Tree;
    fn name(&mut A, A::Name, Self::Lev, Self::Tree, Self::Tree) -> Self::Tree;
    fn art(&mut A, Art<Self::Tree, A::Loc>) -> Self::Tree;
    fn rc(&mut A, Rc<Self::Tree>) -> Self::Tree;
    fn elim<Res, NilC, LeafC, BinC, NameC>(&mut A, Self::Tree, NilC, LeafC, BinC, 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>(&mut A, &Self::Tree, NilC, LeafC, BinC, 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_move<Arg, Res, NilC, LeafC, BinC, NameC>(&mut A, Self::Tree, Arg, NilC, LeafC, BinC, 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 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 { ... }
}

Associated Types

type Lev: Debug + Hash + PartialEq + Eq + Clone

type Tree: Debug + Hash + PartialEq + Eq + Clone

Required Methods

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

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

fn lev_bits() -> Self::Lev

fn lev_zero() -> Self::Lev

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

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

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

fn lev_max_val() -> Self::Lev

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

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

fn bin(&mut A, Self::Lev, Self::Tree, Self::Tree) -> Self::Tree

fn name(&mut A, A::Name, Self::Lev, Self::Tree, Self::Tree) -> Self::Tree

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

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

fn elim<Res, NilC, LeafC, BinC, NameC>(&mut A, Self::Tree, NilC, LeafC, BinC, 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>(&mut A, &Self::Tree, NilC, LeafC, BinC, 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_move<Arg, Res, NilC, LeafC, BinC, NameC>(&mut A, Self::Tree, Arg, NilC, LeafC, BinC, 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

Provided Methods

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

Implementors