Trait iterable::Consumer

pub trait Consumer {
    type Item;
    type IntoIter: Iterator<Item = Self::Item>;

    fn consume(self) -> Self::IntoIter;
}

Required Associated Types

type Item

type IntoIter: Iterator<Item = Self::Item>

Required Methods

fn consume(self) -> Self::IntoIter

Implementations on Foreign Types

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

type Item = T

type IntoIter = IntoIter<T, N>

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

impl<T> Consumer for BinaryHeap<T>

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

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

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

impl<K, V> Consumer for BTreeMap<K, V>

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

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

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

impl<T> Consumer for BTreeSet<T>

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

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

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

impl<K, V> Consumer for HashMap<K, V>

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

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

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

impl<T> Consumer for HashSet<T>

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

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

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

impl<T> Consumer for LinkedList<T>

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

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

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

impl<T> Consumer for VecDeque<T>

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

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

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

impl<'a> Consumer for &'a str

type Item = char

type IntoIter = Chars<'a>

fn consume(self) -> Self::IntoIter

impl Consumer for String

type Item = char

type IntoIter = Chars

fn consume(self) -> Self::IntoIter

impl<'a> Consumer for &'a String

type Item = char

type IntoIter = Chars<'a>

fn consume(self) -> Self::IntoIter

impl<T> Consumer for Vec<T>

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

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

fn consume(self) -> Self::IntoIter

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

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

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

fn consume(self) -> Self::IntoIter

Implementors

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

type Item = T

type IntoIter = Cloned<<I as Consumer>::IntoIter>

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

type Item = T

type IntoIter = Copied<<I as Consumer>::IntoIter>

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

type Item = <I as Consumer>::Item

type IntoIter = Cycle<<I as Consumer>::IntoIter>

impl<I> Consumer for LazyEnumerate<I>where
    I: Consumer,

type Item = (usize, <I as Consumer>::Item)

type IntoIter = Enumerate<<I as Consumer>::IntoIter>

impl<I> Consumer for LazyFlatten<I>where
    I: Consumer,
    I::Item: Consumer,

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

type IntoIter = FlattenIter<<I as Consumer>::IntoIter>

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

type Item = <I as Consumer>::Item

type IntoIter = Rev<<I as Consumer>::IntoIter>

impl<I> Consumer for LazySkip<I>where
    I: Consumer,

type Item = <I as Consumer>::Item

type IntoIter = Skip<<I as Consumer>::IntoIter>

impl<I> Consumer for LazyStepBy<I>where
    I: Consumer,

type Item = <I as Consumer>::Item

type IntoIter = StepBy<<I as Consumer>::IntoIter>

impl<I> Consumer for LazyTake<I>where
    I: Consumer,

type Item = <I as Consumer>::Item

type IntoIter = Take<<I as Consumer>::IntoIter>

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

type Item = <I as Consumer>::Item

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

impl<I, C> Consumer for LazyZip<I, C>where
    I: Consumer,
    C: Consumer,

type Item = (<I as Consumer>::Item, <C as Consumer>::Item)

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

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

type Item = <I as Consumer>::Item

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

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

type Item = <I as Consumer>::Item

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

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

type Item = T

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

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

type Item = <T as Consumer>::Item

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

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

type Item = T

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

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

type Item = T

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

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

type Item = S

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