Trait iterable::Consumer[−][src]

pub trait Consumer {
    type Item;
    type IntoIter: Iterator<Item = Self::Item>;
    fn consume(self) -> Self::IntoIter;
}

Associated Types

type Item[src]

type IntoIter: Iterator<Item = Self::Item>[src]

Required methods

fn consume(self) -> Self::IntoIter[src]

Implementations on Foreign Types

impl<T, const N: usize> Consumer for [T; N][src]

type Item = T

type IntoIter = IntoIter<T, N>

fn consume(self) -> Self::IntoIter[src]

impl<'a, T: 'a, const N: usize> Consumer for &'a [T; N][src]

type Item = <&'a [T; N] as IntoIterator>::Item

type IntoIter = <&'a [T; N] as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<T> Consumer for BinaryHeap<T>[src]

type Item = <BinaryHeap<T> as IntoIterator>::Item

type IntoIter = <BinaryHeap<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a, T: 'a> Consumer for &'a BinaryHeap<T>[src]

type Item = <&'a BinaryHeap<T> as IntoIterator>::Item

type IntoIter = <&'a BinaryHeap<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<K, V> Consumer for BTreeMap<K, V>[src]

type Item = <BTreeMap<K, V> as IntoIterator>::Item

type IntoIter = <BTreeMap<K, V> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a, K: 'a, V: 'a> Consumer for &'a BTreeMap<K, V>[src]

type Item = <&'a BTreeMap<K, V> as IntoIterator>::Item

type IntoIter = <&'a BTreeMap<K, V> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<T> Consumer for BTreeSet<T>[src]

type Item = <BTreeSet<T> as IntoIterator>::Item

type IntoIter = <BTreeSet<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a, T: 'a> Consumer for &'a BTreeSet<T>[src]

type Item = <&'a BTreeSet<T> as IntoIterator>::Item

type IntoIter = <&'a BTreeSet<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<K, V> Consumer for HashMap<K, V>[src]

type Item = <HashMap<K, V> as IntoIterator>::Item

type IntoIter = <HashMap<K, V> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a, K: 'a, V: 'a> Consumer for &'a HashMap<K, V>[src]

type Item = <&'a HashMap<K, V> as IntoIterator>::Item

type IntoIter = <&'a HashMap<K, V> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<T> Consumer for HashSet<T>[src]

type Item = <HashSet<T> as IntoIterator>::Item

type IntoIter = <HashSet<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a, T: 'a> Consumer for &'a HashSet<T>[src]

type Item = <&'a HashSet<T> as IntoIterator>::Item

type IntoIter = <&'a HashSet<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<T> Consumer for LinkedList<T>[src]

type Item = <LinkedList<T> as IntoIterator>::Item

type IntoIter = <LinkedList<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a, T: 'a> Consumer for &'a LinkedList<T>[src]

type Item = <&'a LinkedList<T> as IntoIterator>::Item

type IntoIter = <&'a LinkedList<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<T> Consumer for VecDeque<T>[src]

type Item = <VecDeque<T> as IntoIterator>::Item

type IntoIter = <VecDeque<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a, T: 'a> Consumer for &'a VecDeque<T>[src]

type Item = <&'a VecDeque<T> as IntoIterator>::Item

type IntoIter = <&'a VecDeque<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a, T: 'a> Consumer for &'a [T][src]

type Item = <&'a [T] as IntoIterator>::Item

type IntoIter = <&'a [T] as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a> Consumer for &'a str[src]

type Item = char

type IntoIter = Chars<'a>

fn consume(self) -> Self::IntoIter[src]

impl Consumer for String[src]

type Item = char

type IntoIter = Chars

fn consume(self) -> Self::IntoIter[src]

impl<'a> Consumer for &'a String[src]

type Item = char

type IntoIter = Chars<'a>

fn consume(self) -> Self::IntoIter[src]

impl<T> Consumer for Vec<T>[src]

type Item = <Vec<T> as IntoIterator>::Item

type IntoIter = <Vec<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

impl<'a, T: 'a> Consumer for &'a Vec<T>[src]

type Item = <&'a Vec<T> as IntoIterator>::Item

type IntoIter = <&'a Vec<T> as IntoIterator>::IntoIter

fn consume(self) -> Self::IntoIter[src]

Implementors

impl<'a, I, T> Consumer for LazyCloned<I> where
    T: 'a + Clone,
    I: Consumer<Item = &'a T>, [src]

type Item = T

type IntoIter = Cloned<I::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<'a, I, T> Consumer for LazyCopied<I> where
    T: 'a + Copy,
    I: Consumer<Item = &'a T>, [src]

type Item = T

type IntoIter = Copied<I::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I> Consumer for LazyCycle<I> where
    I: Consumer,
    I::IntoIter: Clone, [src]

type Item = I::Item

type IntoIter = Cycle<I::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I> Consumer for LazyEnumerate<I> where
    I: Consumer, [src]

type Item = (usize, I::Item)

type IntoIter = Enumerate<I::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I> Consumer for LazyFlatten<I> where
    I: Consumer,
    I::Item: Consumer, [src]

type Item = <I::Item as Consumer>::Item

type IntoIter = FlattenIter<I::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I> Consumer for LazyRev<I> where
    I: Consumer,
    I::IntoIter: DoubleEndedIterator, [src]

type Item = I::Item

type IntoIter = Rev<I::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I> Consumer for LazySkip<I> where
    I: Consumer, [src]

type Item = I::Item

type IntoIter = Skip<I::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I> Consumer for LazyStepBy<I> where
    I: Consumer, [src]

type Item = I::Item

type IntoIter = StepBy<I::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I> Consumer for LazyTake<I> where
    I: Consumer, [src]

type Item = I::Item

type IntoIter = Take<I::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I, C> Consumer for LazyChain<I, C> where
    I: Consumer,
    C: Consumer<Item = I::Item>, [src]

type Item = I::Item

type IntoIter = Chain<I::IntoIter, C::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I, C> Consumer for LazyZip<I, C> where
    I: Consumer,
    C: Consumer, [src]

type Item = (I::Item, C::Item)

type IntoIter = Zip<I::IntoIter, C::IntoIter>

fn consume(self) -> Self::IntoIter[src]

impl<I, F> Consumer for LazyFilter<I, F> where
    I: Consumer,
    F: Fn(&I::Item) -> bool, [src]

type Item = I::Item

type IntoIter = Filter<I::IntoIter, F>

fn consume(self) -> Self::IntoIter[src]

impl<I, F> Consumer for LazySkipWhile<I, F> where
    I: Consumer,
    F: Fn(&I::Item) -> bool, [src]

type Item = I::Item

type IntoIter = SkipWhile<I::IntoIter, F>

fn consume(self) -> Self::IntoIter[src]

impl<I, F, T> Consumer for LazyFilterMap<I, F> where
    I: Consumer,
    F: Fn(I::Item) -> Option<T>, [src]

type Item = T

type IntoIter = FilterMap<I::IntoIter, F>

fn consume(self) -> Self::IntoIter[src]

impl<I, F, T> Consumer for LazyFlatMap<I, F> where
    I: Consumer,
    F: Fn(I::Item) -> T,
    T: Consumer, [src]

type Item = <T as Consumer>::Item

type IntoIter = FlattenMapIter<I::IntoIter, F, T>

fn consume(self) -> Self::IntoIter[src]

impl<I, F, T> Consumer for LazyMap<I, F> where
    I: Consumer,
    F: Fn(I::Item) -> T, [src]

type Item = T

type IntoIter = Map<I::IntoIter, F>

fn consume(self) -> Self::IntoIter[src]

impl<I, F, T> Consumer for LazyMapWhile<I, F> where
    I: Consumer,
    F: Fn(I::Item) -> Option<T>, [src]

type Item = T

type IntoIter = MapWhile<I::IntoIter, F>

fn consume(self) -> Self::IntoIter[src]

impl<S, I, F> Consumer for LazyScan<S, I, F> where
    S: Clone,
    I: Consumer,
    F: Fn(S, I::Item) -> S, [src]

type Item = S

type IntoIter = ScanIter<S, I::IntoIter, F>

fn consume(self) -> Self::IntoIter[src]