Trait adapton::catalog::collections::trie::TrieElim

pub trait TrieElim<X>: Debug + Hash + PartialEq + Eq + Clone + 'static {
    fn find(_: &Self, _: &X, _: i64) -> Option<X>;
    fn is_empty(_: &Self) -> bool;
    fn split_atomic(_: Self) -> Self;
    fn elim<Res, NilC, LeafC, BinC, RootC, NameC>(
        _: Self, 
        _: NilC, 
        _: LeafC, 
        _: BinC, 
        _: RootC, 
        _: NameC
    ) -> Res
    where
        NilC: FnOnce(BS) -> Res,
        LeafC: FnOnce(BS, X) -> Res,
        BinC: FnOnce(BS, Self, Self) -> Res,
        RootC: FnOnce(Meta, Self) -> Res,
        NameC: FnOnce(Name, Self) -> Res;
    fn elim_arg<Arg, Res, NilC, LeafC, BinC, RootC, NameC>(
        _: Self, 
        _: Arg, 
        _: NilC, 
        _: LeafC, 
        _: BinC, 
        _: RootC, 
        _: NameC
    ) -> Res
    where
        NilC: FnOnce(BS, Arg) -> Res,
        LeafC: FnOnce(BS, X, Arg) -> Res,
        BinC: FnOnce(BS, Self, Self, Arg) -> Res,
        RootC: FnOnce(Meta, Self, Arg) -> Res,
        NameC: FnOnce(Name, Self, Arg) -> Res;
    fn elim_ref<Res, NilC, LeafC, BinC, RootC, NameC>(
        _: &Self, 
        _: NilC, 
        _: LeafC, 
        _: BinC, 
        _: RootC, 
        _: NameC
    ) -> Res
    where
        NilC: FnOnce(&BS) -> Res,
        LeafC: FnOnce(&BS, &X) -> Res,
        BinC: FnOnce(&BS, &Self, &Self) -> Res,
        RootC: FnOnce(&Meta, &Self) -> Res,
        NameC: FnOnce(&Name, &Self) -> Res;
}

Required methods

fn find(_: &Self, _: &X, _: i64) -> Option<X>

fn is_empty(_: &Self) -> bool

fn split_atomic(_: Self) -> Self

fn elim<Res, NilC, LeafC, BinC, RootC, NameC>(
    _: Self,
    _: NilC,
    _: LeafC,
    _: BinC,
    _: RootC,
    _: NameC
) -> Res where
    NilC: FnOnce(BS) -> Res,
    LeafC: FnOnce(BS, X) -> Res,
    BinC: FnOnce(BS, Self, Self) -> Res,
    RootC: FnOnce(Meta, Self) -> Res,
    NameC: FnOnce(Name, Self) -> Res, 

fn elim_arg<Arg, Res, NilC, LeafC, BinC, RootC, NameC>(
    _: Self,
    _: Arg,
    _: NilC,
    _: LeafC,
    _: BinC,
    _: RootC,
    _: NameC
) -> Res where
    NilC: FnOnce(BS, Arg) -> Res,
    LeafC: FnOnce(BS, X, Arg) -> Res,
    BinC: FnOnce(BS, Self, Self, Arg) -> Res,
    RootC: FnOnce(Meta, Self, Arg) -> Res,
    NameC: FnOnce(Name, Self, Arg) -> Res, 

fn elim_ref<Res, NilC, LeafC, BinC, RootC, NameC>(
    _: &Self,
    _: NilC,
    _: LeafC,
    _: BinC,
    _: RootC,
    _: NameC
) -> Res where
    NilC: FnOnce(&BS) -> Res,
    LeafC: FnOnce(&BS, &X) -> Res,
    BinC: FnOnce(&BS, &Self, &Self) -> Res,
    RootC: FnOnce(&Meta, &Self) -> Res,
    NameC: FnOnce(&Name, &Self) -> Res, 

Loading content...

Implementors

impl<X: Debug + Hash + PartialEq + Eq + Clone + 'static> TrieElim<X> for Trie<X>

fn find(trie: &Self, elt: &X, i: i64) -> Option<X>

fn is_empty(trie: &Self) -> bool

fn split_atomic(trie: Self) -> Self

fn elim<Res, NilC, LeafC, BinC, RootC, NameC>(
    trie: Self,
    nil: NilC,
    leaf: LeafC,
    bin: BinC,
    root: RootC,
    name: NameC
) -> Res where
    NilC: FnOnce(BS) -> Res,
    LeafC: FnOnce(BS, X) -> Res,
    BinC: FnOnce(BS, Self, Self) -> Res,
    RootC: FnOnce(Meta, Self) -> Res,
    NameC: FnOnce(Name, Self) -> Res, 

fn elim_arg<Arg, Res, NilC, LeafC, BinC, RootC, NameC>(
    trie: Self,
    arg: Arg,
    nil: NilC,
    leaf: LeafC,
    bin: BinC,
    root: RootC,
    name: NameC
) -> Res where
    NilC: FnOnce(BS, Arg) -> Res,
    LeafC: FnOnce(BS, X, Arg) -> Res,
    BinC: FnOnce(BS, Self, Self, Arg) -> Res,
    RootC: FnOnce(Meta, Self, Arg) -> Res,
    NameC: FnOnce(Name, Self, Arg) -> Res, 

fn elim_ref<Res, NilC, LeafC, BinC, RootC, NameC>(
    trie: &Self,
    nil: NilC,
    leaf: LeafC,
    bin: BinC,
    root: RootC,
    name: NameC
) -> Res where
    NilC: FnOnce(&BS) -> Res,
    LeafC: FnOnce(&BS, &X) -> Res,
    BinC: FnOnce(&BS, &Self, &Self) -> Res,
    RootC: FnOnce(&Meta, &Self) -> Res,
    NameC: FnOnce(&Name, &Self) -> Res, 

Loading content...