[−][src]Trait iterable::Iterable

pub trait Iterable: Consumer {
    type C;
    type CC;
    type F = Self::C;
    type CF = Self::CC;
    fn count(self) -> usize
    where
        Self: Sized,
    { ... }

    fn last(self) -> Option<Self::Item>
    where
        Self: Sized,
    { ... }

    fn nth(self, n: usize) -> Option<Self::Item>
    where
        Self: Sized,
    { ... }

    fn step_by(self, step: usize) -> Self::C
    where
        Self: Sized,
        Self::C: Producer<Self::Item>,
    { ... }

    fn chain(self, other: impl Consumer<Item = Self::Item>) -> Self::C
    where
        Self: Sized,
        Self::C: Producer<Self::Item>,
    { ... }

    fn zip<E>(self, other: impl Consumer<Item = E>) -> Self::CC
    where
        Self: Sized,
        Self::CC: Producer<(Self::Item, E)>,
    { ... }

    fn map<U>(self, f: impl Fn(Self::Item) -> U) -> Self::CF
    where
        Self: Sized,
        Self::CF: Producer<U>,
    { ... }

    fn foreach(self, f: impl Fn(Self::Item))
    where
        Self: Sized,
    { ... }

    fn filter(self, f: impl Fn(&Self::Item) -> bool) -> Self::C
    where
        Self: Sized,
        Self::C: Producer<Self::Item>,
    { ... }

    fn filter_map<U>(self, f: impl Fn(Self::Item) -> Option<U>) -> Self::CC
    where
        Self: Sized,
        Self::CC: Producer<U>,
    { ... }

    fn enumerate(self) -> Self::CF
    where
        Self: Sized,
        Self::CF: Producer<(usize, Self::Item)>,
    { ... }

    fn skip_while(self, f: impl Fn(&Self::Item) -> bool) -> Self::C
    where
        Self: Sized,
        Self::C: Producer<Self::Item>,
    { ... }

    fn take_while(self, f: impl Fn(&Self::Item) -> bool) -> Self::C
    where
        Self: Sized,
        Self::C: Producer<Self::Item>,
    { ... }

    fn map_while<U>(self, f: impl Fn(Self::Item) -> Option<U>) -> Self::CC
    where
        Self: Sized,
        Self::CC: Producer<U>,
    { ... }

    fn skip(self, n: usize) -> Self::C
    where
        Self: Sized,
        Self::C: Producer<Self::Item>,
    { ... }

    fn take(self, n: usize) -> Self::C
    where
        Self: Sized,
        Self::C: Producer<Self::Item>,
    { ... }

    fn scan<S>(self, state: S, f: impl Fn(S, Self::Item) -> S) -> Self::CC
    where
        S: Clone,
        Self: Sized,
        Self::CC: Producer<S>,
    { ... }

    fn flat_map<U>(self, f: impl Fn(Self::Item) -> U) -> Self::CC
    where
        U: Consumer,
        Self: Sized,
        Self::CC: Producer<U::Item>,
    { ... }

    fn flatten(self) -> Self::CC
    where
        Self: Sized,
        Self::Item: Consumer,
        Self::CC: Producer<<Self::Item as Consumer>::Item>,
    { ... }

    fn by_ref(&self) -> &Self { ... }

    fn partition(self, f: impl Fn(&Self::Item) -> bool) -> (Self::C, Self::C)
    where
        Self: Sized,
        Self::C: GrowableProducer<Self::Item>,
    { ... }

    fn try_fold<S, R>(self, init: S, f: impl Fn(S, Self::Item) -> R) -> R
    where
        Self: Sized,
        R: Try<Ok = S>,
    { ... }

    fn try_for_each<R>(self, f: impl Fn(Self::Item) -> R) -> R
    where
        Self: Sized,
        R: Try<Ok = ()>,
    { ... }

    fn fold<S>(self, init: S, f: impl Fn(S, Self::Item) -> S) -> S
    where
        Self: Sized,
    { ... }

    fn all(self, f: impl Fn(Self::Item) -> bool) -> bool
    where
        Self: Sized,
    { ... }

    fn any(self, f: impl Fn(Self::Item) -> bool) -> bool
    where
        Self: Sized,
    { ... }

    fn find(self, f: impl Fn(&Self::Item) -> bool) -> Option<Self::Item>
    where
        Self: Sized,
    { ... }

    fn find_map<B>(self, f: impl Fn(Self::Item) -> Option<B>) -> Option<B>
    where
        Self: Sized,
    { ... }

    fn position(self, f: impl Fn(Self::Item) -> bool) -> Option<usize>
    where
        Self: Sized,
    { ... }

    fn rposition(self, f: impl Fn(Self::Item) -> bool) -> Option<usize>
    where
        Self: Sized,
        Self::IntoIter: ExactSizeIterator + DoubleEndedIterator,
    { ... }

    fn max(self) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: Ord,
    { ... }

    fn min(self) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: Ord,
    { ... }

    fn max_by_key<B>(self, f: impl Fn(&Self::Item) -> B) -> Option<Self::Item>
    where
        Self: Sized,
        B: Ord,
    { ... }

    fn max_by(
        self, 
        f: impl Fn(&Self::Item, &Self::Item) -> Ordering
    ) -> Option<Self::Item>
    where
        Self: Sized,
    { ... }

    fn min_by_key<B>(self, f: impl Fn(&Self::Item) -> B) -> Option<Self::Item>
    where
        Self: Sized,
        B: Ord,
    { ... }

    fn min_by(
        self, 
        f: impl Fn(&Self::Item, &Self::Item) -> Ordering
    ) -> Option<Self::Item>
    where
        Self: Sized,
    { ... }

    fn rev(self) -> Self::F
    where
        Self: Sized,
        Self::F: Producer<Self::Item>,
        Self::IntoIter: DoubleEndedIterator,
    { ... }

    fn unzip<A, B>(self) -> (Self::CF, Self::CF)
    where
        Self: Sized,
        Self: Consumer<Item = (A, B)>,
        Self::CF: GrowableProducer<A>,
        Self::CF: GrowableProducer<B>,
    { ... }

    fn copied<'a, T>(self) -> Self::CF
    where
        T: 'a + Copy,
        Self: Sized,
        Self: Consumer<Item = &'a T>,
        Self::CF: Producer<T>,
    { ... }

    fn cloned<'a, T>(self) -> Self::CF
    where
        T: 'a + Clone,
        Self: Sized,
        Self: Consumer<Item = &'a T>,
        Self::CF: Producer<T>,
    { ... }

    fn sum<S>(self) -> S
    where
        Self: Sized,
        S: Sum<Self::Item>,
    { ... }

    fn product<S>(self) -> S
    where
        Self: Sized,
        S: Product<Self::Item>,
    { ... }

    fn cmp<I>(self, other: I) -> Ordering
    where
        I: Consumer<Item = Self::Item>,
        Self: Sized,
        Self::Item: Ord,
    { ... }

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
        I: Consumer,
        Self: Sized,
        Self::Item: PartialOrd<<I as Consumer>::Item>,
    { ... }

    fn eq<I>(self, other: I) -> bool
    where
        I: Consumer,
        Self: Sized,
        Self::Item: PartialEq<<I as Consumer>::Item>,
    { ... }

    fn ne<I>(self, other: I) -> bool
    where
        I: Consumer,
        Self: Sized,
        Self::Item: PartialEq<<I as Consumer>::Item>,
    { ... }

    fn lt<I>(self, other: I) -> bool
    where
        I: Consumer,
        Self: Sized,
        Self::Item: PartialOrd<<I as Consumer>::Item>,
    { ... }

    fn le<I>(self, other: I) -> bool
    where
        I: Consumer,
        Self: Sized,
        Self::Item: PartialOrd<<I as Consumer>::Item>,
    { ... }

    fn gt<I>(self, other: I) -> bool
    where
        I: Consumer,
        Self: Sized,
        Self::Item: PartialOrd<<I as Consumer>::Item>,
    { ... }

    fn ge<I>(self, other: I) -> bool
    where
        I: Consumer,
        Self: Sized,
        Self::Item: PartialOrd<<I as Consumer>::Item>,
    { ... }

    fn join(self, sep: &str) -> String
    where
        Self: Sized,
        Self::Item: Display,
    { ... }

    fn lazy_step_by(self, step: usize) -> LazyStepBy<Self>
    where
        Self: Sized,
    { ... }

    fn lazy_chain<C: Consumer>(self, c: C) -> LazyChain<Self, C>
    where
        Self: Sized,
    { ... }

    fn lazy_zip<C: Consumer>(self, c: C) -> LazyZip<Self, C>
    where
        Self: Sized,
    { ... }

    fn lazy_filter<F: Fn(&Self::Item) -> bool>(
        self, 
        f: F
    ) -> LazyFilter<Self, F>
    where
        Self: Sized,
    { ... }

    fn lazy_map<T, F: Fn(Self::Item) -> T>(self, f: F) -> LazyMap<Self, F>
    where
        Self: Sized,
    { ... }

    fn lazy_filter_map<T, F: Fn(Self::Item) -> Option<T>>(
        self, 
        f: F
    ) -> LazyFilterMap<Self, F>
    where
        Self: Sized,
    { ... }

    fn lazy_enumerate(self) -> LazyEnumerate<Self>
    where
        Self: Sized,
    { ... }

    fn lazy_skip_while<F: Fn(&Self::Item) -> bool>(
        self, 
        f: F
    ) -> LazySkipWhile<Self, F>
    where
        Self: Sized,
    { ... }

    fn lazy_map_while<T, F: Fn(Self::Item) -> Option<T>>(
        self, 
        f: F
    ) -> LazyMapWhile<Self, F>
    where
        Self: Sized,
    { ... }

    fn lazy_skip(self, n: usize) -> LazySkip<Self>
    where
        Self: Sized,
    { ... }

    fn lazy_take(self, n: usize) -> LazyTake<Self>
    where
        Self: Sized,
    { ... }

    fn lazy_scan<S, F: Fn(S, Self::Item) -> S>(
        self, 
        state: S, 
        f: F
    ) -> LazyScan<S, Self, F>
    where
        Self: Sized,
    { ... }

    fn lazy_flat_map<T: Consumer, F: Fn(Self::Item) -> T>(
        self, 
        f: F
    ) -> LazyFlatMap<Self, F>
    where
        Self: Sized,
    { ... }

    fn lazy_flatten(self) -> LazyFlatten<Self>
    where
        Self: Sized,
        Self::Item: Consumer,
    { ... }

    fn lazy_rev(self) -> LazyRev<Self>
    where
        Self: Sized,
        Self::IntoIter: DoubleEndedIterator,
    { ... }

    fn lazy_copied<'a, T>(self) -> LazyCopied<Self>
    where
        T: 'a + Copy,
        Self: Sized,
        Self: Consumer<Item = &'a T>,
    { ... }

    fn lazy_cloned<'a, T>(self) -> LazyCloned<Self>
    where
        T: 'a + Clone,
        Self: Sized,
        Self: Consumer<Item = &'a T>,
    { ... }

    fn lazy_cycle(self) -> LazyCycle<Self>
    where
        Self: Sized,
        Self::IntoIter: Clone,
    { ... }
}

Associated Types

type C

type CC

type F = Self::C

type CF = Self::CC

Loading content...

Provided methods

fn count(self) -> usize where
    Self: Sized, 

fn last(self) -> Option<Self::Item> where
    Self: Sized, 

fn nth(self, n: usize) -> Option<Self::Item> where
    Self: Sized, 

fn step_by(self, step: usize) -> Self::C where
    Self: Sized,
    Self::C: Producer<Self::Item>, 

fn chain(self, other: impl Consumer<Item = Self::Item>) -> Self::C where
    Self: Sized,
    Self::C: Producer<Self::Item>, 

fn zip<E>(self, other: impl Consumer<Item = E>) -> Self::CC where
    Self: Sized,
    Self::CC: Producer<(Self::Item, E)>, 

fn map<U>(self, f: impl Fn(Self::Item) -> U) -> Self::CF where
    Self: Sized,
    Self::CF: Producer<U>, 

fn foreach(self, f: impl Fn(Self::Item)) where
    Self: Sized, 

fn filter(self, f: impl Fn(&Self::Item) -> bool) -> Self::C where
    Self: Sized,
    Self::C: Producer<Self::Item>, 

fn filter_map<U>(self, f: impl Fn(Self::Item) -> Option<U>) -> Self::CC where
    Self: Sized,
    Self::CC: Producer<U>, 

fn enumerate(self) -> Self::CF where
    Self: Sized,
    Self::CF: Producer<(usize, Self::Item)>, 

fn skip_while(self, f: impl Fn(&Self::Item) -> bool) -> Self::C where
    Self: Sized,
    Self::C: Producer<Self::Item>, 

fn take_while(self, f: impl Fn(&Self::Item) -> bool) -> Self::C where
    Self: Sized,
    Self::C: Producer<Self::Item>, 

fn map_while<U>(self, f: impl Fn(Self::Item) -> Option<U>) -> Self::CC where
    Self: Sized,
    Self::CC: Producer<U>, 

fn skip(self, n: usize) -> Self::C where
    Self: Sized,
    Self::C: Producer<Self::Item>, 

fn take(self, n: usize) -> Self::C where
    Self: Sized,
    Self::C: Producer<Self::Item>, 

fn scan<S>(self, state: S, f: impl Fn(S, Self::Item) -> S) -> Self::CC where
    S: Clone,
    Self: Sized,
    Self::CC: Producer<S>, 

fn flat_map<U>(self, f: impl Fn(Self::Item) -> U) -> Self::CC where
    U: Consumer,
    Self: Sized,
    Self::CC: Producer<U::Item>, 

fn flatten(self) -> Self::CC where
    Self: Sized,
    Self::Item: Consumer,
    Self::CC: Producer<<Self::Item as Consumer>::Item>, 

fn by_ref(&self) -> &Self

fn partition(self, f: impl Fn(&Self::Item) -> bool) -> (Self::C, Self::C) where
    Self: Sized,
    Self::C: GrowableProducer<Self::Item>, 

fn try_fold<S, R>(self, init: S, f: impl Fn(S, Self::Item) -> R) -> R where
    Self: Sized,
    R: Try<Ok = S>, 

fn try_for_each<R>(self, f: impl Fn(Self::Item) -> R) -> R where
    Self: Sized,
    R: Try<Ok = ()>, 

fn fold<S>(self, init: S, f: impl Fn(S, Self::Item) -> S) -> S where
    Self: Sized, 

fn all(self, f: impl Fn(Self::Item) -> bool) -> bool where
    Self: Sized, 

fn any(self, f: impl Fn(Self::Item) -> bool) -> bool where
    Self: Sized, 

fn find(self, f: impl Fn(&Self::Item) -> bool) -> Option<Self::Item> where
    Self: Sized, 

fn find_map<B>(self, f: impl Fn(Self::Item) -> Option<B>) -> Option<B> where
    Self: Sized, 

fn position(self, f: impl Fn(Self::Item) -> bool) -> Option<usize> where
    Self: Sized, 

fn rposition(self, f: impl Fn(Self::Item) -> bool) -> Option<usize> where
    Self: Sized,
    Self::IntoIter: ExactSizeIterator + DoubleEndedIterator, 

fn max(self) -> Option<Self::Item> where
    Self: Sized,
    Self::Item: Ord, 

fn min(self) -> Option<Self::Item> where
    Self: Sized,
    Self::Item: Ord, 

fn max_by_key<B>(self, f: impl Fn(&Self::Item) -> B) -> Option<Self::Item> where
    Self: Sized,
    B: Ord, 

fn max_by(
    self,
    f: impl Fn(&Self::Item, &Self::Item) -> Ordering
) -> Option<Self::Item> where
    Self: Sized, 

fn min_by_key<B>(self, f: impl Fn(&Self::Item) -> B) -> Option<Self::Item> where
    Self: Sized,
    B: Ord, 

fn min_by(
    self,
    f: impl Fn(&Self::Item, &Self::Item) -> Ordering
) -> Option<Self::Item> where
    Self: Sized, 

fn rev(self) -> Self::F where
    Self: Sized,
    Self::F: Producer<Self::Item>,
    Self::IntoIter: DoubleEndedIterator, 

fn unzip<A, B>(self) -> (Self::CF, Self::CF) where
    Self: Sized,
    Self: Consumer<Item = (A, B)>,
    Self::CF: GrowableProducer<A>,
    Self::CF: GrowableProducer<B>, 

fn copied<'a, T>(self) -> Self::CF where
    T: 'a + Copy,
    Self: Sized,
    Self: Consumer<Item = &'a T>,
    Self::CF: Producer<T>, 

fn cloned<'a, T>(self) -> Self::CF where
    T: 'a + Clone,
    Self: Sized,
    Self: Consumer<Item = &'a T>,
    Self::CF: Producer<T>, 

fn sum<S>(self) -> S where
    Self: Sized,
    S: Sum<Self::Item>, 

fn product<S>(self) -> S where
    Self: Sized,
    S: Product<Self::Item>, 

fn cmp<I>(self, other: I) -> Ordering where
    I: Consumer<Item = Self::Item>,
    Self: Sized,
    Self::Item: Ord, 

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
    I: Consumer,
    Self: Sized,
    Self::Item: PartialOrd<<I as Consumer>::Item>, 

fn eq<I>(self, other: I) -> bool where
    I: Consumer,
    Self: Sized,
    Self::Item: PartialEq<<I as Consumer>::Item>, 

fn ne<I>(self, other: I) -> bool where
    I: Consumer,
    Self: Sized,
    Self::Item: PartialEq<<I as Consumer>::Item>, 

fn lt<I>(self, other: I) -> bool where
    I: Consumer,
    Self: Sized,
    Self::Item: PartialOrd<<I as Consumer>::Item>, 

fn le<I>(self, other: I) -> bool where
    I: Consumer,
    Self: Sized,
    Self::Item: PartialOrd<<I as Consumer>::Item>, 

fn gt<I>(self, other: I) -> bool where
    I: Consumer,
    Self: Sized,
    Self::Item: PartialOrd<<I as Consumer>::Item>, 

fn ge<I>(self, other: I) -> bool where
    I: Consumer,
    Self: Sized,
    Self::Item: PartialOrd<<I as Consumer>::Item>, 

fn join(self, sep: &str) -> String where
    Self: Sized,
    Self::Item: Display, 

fn lazy_step_by(self, step: usize) -> LazyStepBy<Self> where
    Self: Sized, 

fn lazy_chain<C: Consumer>(self, c: C) -> LazyChain<Self, C> where
    Self: Sized, 

fn lazy_zip<C: Consumer>(self, c: C) -> LazyZip<Self, C> where
    Self: Sized, 

fn lazy_filter<F: Fn(&Self::Item) -> bool>(self, f: F) -> LazyFilter<Self, F> where
    Self: Sized, 

fn lazy_map<T, F: Fn(Self::Item) -> T>(self, f: F) -> LazyMap<Self, F> where
    Self: Sized, 

fn lazy_filter_map<T, F: Fn(Self::Item) -> Option<T>>(
    self,
    f: F
) -> LazyFilterMap<Self, F> where
    Self: Sized, 

fn lazy_enumerate(self) -> LazyEnumerate<Self> where
    Self: Sized, 

fn lazy_skip_while<F: Fn(&Self::Item) -> bool>(
    self,
    f: F
) -> LazySkipWhile<Self, F> where
    Self: Sized, 

fn lazy_map_while<T, F: Fn(Self::Item) -> Option<T>>(
    self,
    f: F
) -> LazyMapWhile<Self, F> where
    Self: Sized, 

fn lazy_skip(self, n: usize) -> LazySkip<Self> where
    Self: Sized, 

fn lazy_take(self, n: usize) -> LazyTake<Self> where
    Self: Sized, 

fn lazy_scan<S, F: Fn(S, Self::Item) -> S>(
    self,
    state: S,
    f: F
) -> LazyScan<S, Self, F> where
    Self: Sized, 

fn lazy_flat_map<T: Consumer, F: Fn(Self::Item) -> T>(
    self,
    f: F
) -> LazyFlatMap<Self, F> where
    Self: Sized, 

fn lazy_flatten(self) -> LazyFlatten<Self> where
    Self: Sized,
    Self::Item: Consumer, 

fn lazy_rev(self) -> LazyRev<Self> where
    Self: Sized,
    Self::IntoIter: DoubleEndedIterator, 

fn lazy_copied<'a, T>(self) -> LazyCopied<Self> where
    T: 'a + Copy,
    Self: Sized,
    Self: Consumer<Item = &'a T>, 

fn lazy_cloned<'a, T>(self) -> LazyCloned<Self> where
    T: 'a + Clone,
    Self: Sized,
    Self: Consumer<Item = &'a T>, 

fn lazy_cycle(self) -> LazyCycle<Self> where
    Self: Sized,
    Self::IntoIter: Clone, 

Loading content...

Implementations on Foreign Types

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

type C = Vec<&'a T>

type CC = Vec<U>

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

type C = Self

type CC = Vec<U>

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

type C = HashMap<&'a K, &'a V>

type CC = Vec<U>

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

type C = Self

type CC = HashSet<U>

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

type C = HashSet<&'a T>

type CC = HashSet<U>

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

type C = Self

type CC = BTreeSet<U>

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

type C = BTreeSet<&'a T>

type CC = BTreeSet<U>

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

type C = Self

type CC = Vec<U>

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

type C = BTreeMap<&'a K, &'a V>

type CC = Vec<U>

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

type C = BinaryHeap<T>

type CC = BinaryHeap<U>

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

type C = BinaryHeap<&'a T>

type CC = BinaryHeap<U>

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

type C = Self

type CC = LinkedList<U>

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

type C = LinkedList<&'a T>

type CC = LinkedList<U>

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

type C = Self

type CC = VecDeque<U>

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

type C = VecDeque<&'a T>

type CC = VecDeque<U>

impl Iterable for String[src]

type C = Self

type CC = Vec<U>

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

type C = String

type CC = Vec<U>

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

type C = String

type CC = Vec<U>

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

type C = Vec<T>

type CC = Vec<U>

type F = [T; N]

type CF = [U; N]

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

type C = Vec<&'a T>

type CC = Vec<U>

type F = [&'a T; N]

type CF = [U; N]

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

type C = Self

type CC = Vec<U>

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

type C = Vec<&'a T>

type CC = Vec<U>

Loading content...

Implementors

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

type C = I::CC

type CC = I::CC

type F = I::CF

type CF = I::CF

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

type C = I::CC

type CC = I::CC

type F = I::CF

type CF = I::CF

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

type C = I::C

type CC = I::CC

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

type C = I::CC

type CC = I::CC

type F = I::CF

type CF = I::CF

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

type C = I::CC

type CC = I::CC

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

type C = I::C

type CC = I::CC

type F = I::F

type CF = I::CF

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

type C = I::C

type CC = I::CC

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

type C = I::C

type CC = I::CC

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

type C = I::C

type CC = I::CC

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

type C = I::C

type CC = I::CC

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

type C = I::CC

type CC = I::CC

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

type C = I::C

type CC = I::CC

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

type C = I::C

type CC = I::CC

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

type C = I::CC

type CC = I::CC

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

type C = I::CC

type CC = I::CC

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

type C = I::CC

type CC = I::CC

type F = I::CF

type CF = I::CF

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

type C = I::CC

type CC = I::CC

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

type C = I::CC

type CC = I::CC

Loading content...