Trait brontes_types::tree::util::base::TreeBase

pub trait TreeBase<V: NormalizedAction>: Iterator {
    // Provided methods
    fn dedup<'a, KS, RS, FromI, Out, Zip>(
        self,
        parent_actions: KS,
        possible_prune_actions: RS,
    ) -> TreeIterator<V, Out> 
       where Self: Sized + DedupOperation<'a, FromI, Out, V, Self::Item, Zip> + 'a + TreeIter<V>,
             Out: Iterator,
             V: NormalizedAction + 'a,
             KS: 'a + InTupleFnOutVec<V>,
             RS: 'a + InTupleFnOutVec<V>,
             FromI: IntoZip<Zip>,
             <KS as InTupleFnOutVec<V>>::Out: Dedups<V, RS::Out, FromI, Zip>,
             IntoIter<V>: ActionSplit<KS::Out, KS, V> + ActionSplit<RS::Out, RS, V>,
             Zip: SplitIterZip<IntoIter<V>> { ... }
    fn t_full_map<R, F>(self, f: F) -> R
       where Self: Sized + TreeIter<V>,
             F: FnMut((Arc<BlockTree<V>>, Self)) -> R { ... }
    fn full_map<R, F>(self, f: F) -> R
       where Self: Sized + TreeIter<V>,
             F: FnMut(Self) -> R { ... }
    fn t_full_filter_map<R, F>(self, f: F) -> Option<R>
       where Self: Sized + TreeIter<V>,
             F: FnMut((Arc<BlockTree<V>>, Self)) -> Option<R> { ... }
    fn t_map<R, F>(self, f: F) -> TreeIterator<V, Map<Self, F>> 
       where Self: Sized + TreeIter<V>,
             F: FnMut(Self::Item) -> R { ... }
    fn t_full_filter<F>(self, f: F) -> Option<Self>
       where Self: Sized + TreeIter<V>,
             F: FnMut(Arc<BlockTree<V>>, &Self) -> bool { ... }
    fn t_filter<F>(self, f: F) -> TreeIterator<V, FilterTree<V, Self, F>> 
       where Self: Sized + TreeIter<V>,
             F: for<'a> FnMut(Arc<BlockTree<V>>, &Self::Item) -> bool { ... }
    fn t_filter_map<R, F>(
        self,
        f: F,
    ) -> TreeIterator<V, FilterMapTree<V, Self, F>> 
       where Self: Sized + TreeIter<V>,
             F: FnMut(Arc<BlockTree<V>>, Self::Item) -> Option<R> { ... }
    fn tree_zip_with<O>(self, other: O) -> TreeIterator<V, Self::Out> 
       where Self: SplitIterZip<O> + Sized + TreeIter<V>,
             O: Iterator { ... }
    fn zip_with<O>(self, other: O) -> Self::Out
       where Self: SplitIterZip<O> + Sized,
             O: Iterator { ... }
    fn merge_iter<O, B>(self) -> TreeIterator<V, B> 
       where Self: Sized + MergeIter<O, B> + TreeIter<V>,
             B: Iterator<Item = O> { ... }
    fn split_into_actions<FromI, Fns, Out>(
        self,
        fns: Fns,
    ) -> TreeIterator<V, Out> 
       where Self: Sized + Iterator + TreeIter<V> + ActionSplit<FromI, Fns, V>,
             Out: Iterator,
             FromI: IntoZip<Out> { ... }
}

Base functionality for TreeIter, These are almost all setup or internal tools used to deal with complexity.

Provided Methods

fn dedup<'a, KS, RS, FromI, Out, Zip>( self, parent_actions: KS, possible_prune_actions: RS, ) -> TreeIterator<V, Out>

where Self: Sized + DedupOperation<'a, FromI, Out, V, Self::Item, Zip> + 'a + TreeIter<V>, Out: Iterator, V: NormalizedAction + 'a, KS: 'a + InTupleFnOutVec<V>, RS: 'a + InTupleFnOutVec<V>, FromI: IntoZip<Zip>, <KS as InTupleFnOutVec<V>>::Out: Dedups<V, RS::Out, FromI, Zip>, IntoIter<V>: ActionSplit<KS::Out, KS, V> + ActionSplit<RS::Out, RS, V>, Zip: SplitIterZip<IntoIter<V>>,

fn t_full_map<R, F>(self, f: F) -> R

where Self: Sized + TreeIter<V>, F: FnMut((Arc<BlockTree<V>>, Self)) -> R,

fn full_map<R, F>(self, f: F) -> R

where Self: Sized + TreeIter<V>, F: FnMut(Self) -> R,

fn t_full_filter_map<R, F>(self, f: F) -> Option<R>

where Self: Sized + TreeIter<V>, F: FnMut((Arc<BlockTree<V>>, Self)) -> Option<R>,

fn t_map<R, F>(self, f: F) -> TreeIterator<V, Map<Self, F>>

where Self: Sized + TreeIter<V>, F: FnMut(Self::Item) -> R,

fn t_full_filter<F>(self, f: F) -> Option<Self>

where Self: Sized + TreeIter<V>, F: FnMut(Arc<BlockTree<V>>, &Self) -> bool,

fn t_filter<F>(self, f: F) -> TreeIterator<V, FilterTree<V, Self, F>>

where Self: Sized + TreeIter<V>, F: for<'a> FnMut(Arc<BlockTree<V>>, &Self::Item) -> bool,

fn t_filter_map<R, F>(self, f: F) -> TreeIterator<V, FilterMapTree<V, Self, F>>

where Self: Sized + TreeIter<V>, F: FnMut(Arc<BlockTree<V>>, Self::Item) -> Option<R>,

fn tree_zip_with<O>(self, other: O) -> TreeIterator<V, Self::Out>

where Self: SplitIterZip<O> + Sized + TreeIter<V>, O: Iterator,

fn zip_with<O>(self, other: O) -> Self::Out

where Self: SplitIterZip<O> + Sized, O: Iterator,

fn merge_iter<O, B>(self) -> TreeIterator<V, B>

where Self: Sized + MergeIter<O, B> + TreeIter<V>, B: Iterator<Item = O>,

Merges the iterator into type O.

fn split_into_actions<FromI, Fns, Out>(self, fns: Fns) -> TreeIterator<V, Out>

where Self: Sized + Iterator + TreeIter<V> + ActionSplit<FromI, Fns, V>, Out: Iterator, FromI: IntoZip<Out>,

Implementors

impl<T: Sized + Iterator, V: NormalizedAction> TreeBase<V> for T