Trait Iterable

pub trait Iterable: Consumer {
    type C;
    type CC<U>;
    type F;
    type CF<U>;

    // 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<(Self::Item, E)>
       where Self: Sized,
             Self::CC<(Self::Item, E)>: Producer<(Self::Item, E)> { ... }
    fn map<U>(self, f: impl Fn(Self::Item) -> U) -> Self::CF<U>
       where Self: Sized,
             Self::CF<U>: 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<U>
       where Self: Sized,
             Self::CC<U>: Producer<U> { ... }
    fn enumerate(self) -> Self::CF<(usize, Self::Item)>
       where Self: Sized,
             Self::CF<(usize, Self::Item)>: 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<U>
       where Self: Sized,
             Self::CC<U>: 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<S>
       where S: Clone,
             Self: Sized,
             Self::CC<S>: Producer<S> { ... }
    fn flat_map<U>(self, f: impl Fn(Self::Item) -> U) -> Self::CC<U::Item>
       where U: Consumer,
             Self: Sized,
             Self::CC<U::Item>: Producer<U::Item> { ... }
    fn flatten(self) -> Self::CC<<Self::Item as Consumer>::Item>
       where Self: Sized,
             Self::Item: Consumer,
             Self::CC<<Self::Item as Consumer>::Item>: 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::Map<S>
       where Self: Sized,
             R: TryExt<Output = S> { ... }
    fn try_for_each<R>(self, f: impl Fn(Self::Item) -> R) -> R::Map<()>
       where Self: Sized,
             R: TryExt<Output = ()> { ... }
    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 unzip<A, B>(self) -> (Self::CF<A>, Self::CF<B>)
       where Self: Sized + Consumer<Item = (A, B)>,
             Self::CF<A>: GrowableProducer<A>,
             Self::CF<B>: GrowableProducer<B> { ... }
    fn copied<'a, T>(self) -> Self::CF<T>
       where T: 'a + Copy,
             Self: Sized + Consumer<Item = &'a T>,
             Self::CF<T>: Producer<T> { ... }
    fn cloned<'a, T>(self) -> Self::CF<T>
       where T: 'a + Clone,
             Self: Sized + Consumer<Item = &'a T>,
             Self::CF<T>: 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 add_one(self, a: Self::Item) -> Self::C
       where Self: Sized,
             Self::C: GrowableProducer<Self::Item> { ... }
    fn try_add_one<R>(self, r: R) -> R::Map<Self::C>
       where R: TryExt<Output = Self::Item>,
             Self: Sized,
             Self::C: GrowableProducer<Self::Item> { ... }
    fn try_map<B, R, F>(self, f: F) -> R::Map<Self::CC<B>>
       where F: Fn(Self::Item) -> R,
             R: TryExt<Output = B>,
             Self: Sized,
             Self::CC<B>: GrowableProducer<B> { ... }
    fn try_flat_map<B, R, F>(self, f: F) -> R::Map<Self::CC<B::Item>>
       where F: Fn(Self::Item) -> R,
             R: TryExt<Output = B>,
             B: Consumer,
             Self: Sized,
             Self::CC<B::Item>: GrowableProducer<B::Item> { ... }
    fn try_flatten(
        self,
    ) -> <Self::Item as TryExt>::Map<Self::CC<<<Self::Item as TryExt>::Output as Consumer>::Item>>
       where Self: Sized,
             Self::Item: TryExt,
             <Self::Item as TryExt>::Output: Consumer,
             Self::CC<<<Self::Item as TryExt>::Output as Consumer>::Item>: GrowableProducer<<<Self::Item as TryExt>::Output as Consumer>::Item> { ... }
    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_copied<'a, T>(self) -> LazyCopied<Self>
       where T: 'a + Copy,
             Self: Sized + Consumer<Item = &'a T> { ... }
    fn lazy_cloned<'a, T>(self) -> LazyCloned<Self>
       where T: 'a + Clone,
             Self: Sized + Consumer<Item = &'a T> { ... }
    fn lazy_cycle(self) -> LazyCycle<Self>
       where Self: Sized,
             Self::IntoIter: Clone { ... }
}

Required Associated Types

type C

type CC<U>

type F

type CF<U>

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<(Self::Item, E)>

where Self: Sized, Self::CC<(Self::Item, E)>: Producer<(Self::Item, E)>,

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

where Self: Sized, Self::CF<U>: 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<U>

where Self: Sized, Self::CC<U>: Producer<U>,

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

where Self: Sized, Self::CF<(usize, Self::Item)>: 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<U>

where Self: Sized, Self::CC<U>: 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<S>

where S: Clone, Self: Sized, Self::CC<S>: Producer<S>,

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

where U: Consumer, Self: Sized, Self::CC<U::Item>: Producer<U::Item>,

fn flatten(self) -> Self::CC<<Self::Item as Consumer>::Item>

where Self: Sized, Self::Item: Consumer, Self::CC<<Self::Item as Consumer>::Item>: 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::Map<S>

where Self: Sized, R: TryExt<Output = S>,

fn try_for_each<R>(self, f: impl Fn(Self::Item) -> R) -> R::Map<()>

where Self: Sized, R: TryExt<Output = ()>,

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 unzip<A, B>(self) -> (Self::CF<A>, Self::CF<B>)

where Self: Sized + Consumer<Item = (A, B)>, Self::CF<A>: GrowableProducer<A>, Self::CF<B>: GrowableProducer<B>,

fn copied<'a, T>(self) -> Self::CF<T>

where T: 'a + Copy, Self: Sized + Consumer<Item = &'a T>, Self::CF<T>: Producer<T>,

fn cloned<'a, T>(self) -> Self::CF<T>

where T: 'a + Clone, Self: Sized + Consumer<Item = &'a T>, Self::CF<T>: 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 add_one(self, a: Self::Item) -> Self::C

where Self: Sized, Self::C: GrowableProducer<Self::Item>,

fn try_add_one<R>(self, r: R) -> R::Map<Self::C>

where R: TryExt<Output = Self::Item>, Self: Sized, Self::C: GrowableProducer<Self::Item>,

fn try_map<B, R, F>(self, f: F) -> R::Map<Self::CC<B>>

where F: Fn(Self::Item) -> R, R: TryExt<Output = B>, Self: Sized, Self::CC<B>: GrowableProducer<B>,

fn try_flat_map<B, R, F>(self, f: F) -> R::Map<Self::CC<B::Item>>

where F: Fn(Self::Item) -> R, R: TryExt<Output = B>, B: Consumer, Self: Sized, Self::CC<B::Item>: GrowableProducer<B::Item>,

fn try_flatten( self, ) -> <Self::Item as TryExt>::Map<Self::CC<<<Self::Item as TryExt>::Output as Consumer>::Item>>

where Self: Sized, Self::Item: TryExt, <Self::Item as TryExt>::Output: Consumer, Self::CC<<<Self::Item as TryExt>::Output as Consumer>::Item>: GrowableProducer<<<Self::Item as TryExt>::Output as Consumer>::Item>,

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_copied<'a, T>(self) -> LazyCopied<Self>

where T: 'a + Copy, Self: Sized + Consumer<Item = &'a T>,

fn lazy_cloned<'a, T>(self) -> LazyCloned<Self>

where T: 'a + Clone, Self: Sized + Consumer<Item = &'a T>,

fn lazy_cycle(self) -> LazyCycle<Self>

where Self: Sized, Self::IntoIter: Clone,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Iterable for String

type C = String

type CC<U> = Vec<U>

type F = String

type CF<U> = Vec<U>

fn add_one(self, a: Self::Item) -> Self::C

impl<'a> Iterable for &'a str

type C = String

type CC<U> = Vec<U>

type F = String

type CF<U> = Vec<U>

impl<'a> Iterable for &'a String

type C = String

type CC<U> = Vec<U>

type F = String

type CF<U> = Vec<U>

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

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

type CC<U> = Vec<U>

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

type CF<U> = Vec<U>

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

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

type CC<U> = Vec<U>

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

type CF<U> = Vec<U>

impl<'a, T> Iterable for &'a LinkedList<T>

type C = LinkedList<&'a T>

type CC<U> = LinkedList<U>

type F = LinkedList<&'a T>

type CF<U> = LinkedList<U>

impl<'a, T> Iterable for &'a VecDeque<T>

type C = VecDeque<&'a T>

type CC<U> = VecDeque<U>

type F = VecDeque<&'a T>

type CF<U> = VecDeque<U>

impl<'a, T> Iterable for &'a HashSet<T>

type C = HashSet<&'a T>

type CC<U> = HashSet<U>

type F = HashSet<&'a T>

type CF<U> = HashSet<U>

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

type C = Vec<&'a T>

type CC<U> = Vec<U>

type F = Vec<&'a T>

type CF<U> = Vec<U>

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

type C = BinaryHeap<&'a T>

type CC<U> = BinaryHeap<U>

type F = BinaryHeap<&'a T>

type CF<U> = BinaryHeap<U>

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

type C = BTreeSet<&'a T>

type CC<U> = BTreeSet<U>

type F = BTreeSet<&'a T>

type CF<U> = BTreeSet<U>

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

type C = Vec<&'a T>

type CC<U> = Vec<U>

type F = Vec<&'a T>

type CF<U> = Vec<U>

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

type C = Vec<&'a T>

type CC<U> = Vec<U>

type F = [&'a T; N]

type CF<U> = [U; N]

fn unzip<A, B>(self) -> (Self::CF<A>, Self::CF<B>)

where Self: Sized + Iterable<Item = (A, B)>,

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

type C = BTreeMap<K, V>

type CC<U> = Vec<U>

type F = BTreeMap<K, V>

type CF<U> = Vec<U>

fn add_one(self, a: Self::Item) -> Self::C

where Self::C: GrowableProducer<Self::Item>,

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

type C = HashMap<K, V>

type CC<U> = Vec<U>

type F = HashMap<K, V>

type CF<U> = Vec<U>

fn add_one(self, a: Self::Item) -> Self::C

where Self::C: GrowableProducer<Self::Item>,

impl<T> Iterable for BinaryHeap<T>

type C = BinaryHeap<T>

type CC<U> = BinaryHeap<U>

type F = BinaryHeap<T>

type CF<U> = BinaryHeap<U>

fn add_one(self, a: Self::Item) -> Self::C

where Self::C: GrowableProducer<Self::Item>,

impl<T> Iterable for BTreeSet<T>

type C = BTreeSet<T>

type CC<U> = BTreeSet<U>

type F = BTreeSet<T>

type CF<U> = BTreeSet<U>

fn add_one(self, a: Self::Item) -> Self::C

where Self::C: GrowableProducer<Self::Item>,

impl<T> Iterable for LinkedList<T>

type C = LinkedList<T>

type CC<U> = LinkedList<U>

type F = LinkedList<T>

type CF<U> = LinkedList<U>

fn add_one(self, a: Self::Item) -> Self::C

impl<T> Iterable for VecDeque<T>

type C = VecDeque<T>

type CC<U> = VecDeque<U>

type F = VecDeque<T>

type CF<U> = VecDeque<U>

fn add_one(self, a: Self::Item) -> Self::C

impl<T> Iterable for Vec<T>

type C = Vec<T>

type CC<U> = Vec<U>

type F = Vec<T>

type CF<U> = Vec<U>

fn add_one(self, a: Self::Item) -> Self::C

impl<T> Iterable for HashSet<T>

type C = HashSet<T>

type CC<U> = HashSet<U>

type F = HashSet<T>

type CF<U> = HashSet<U>

fn add_one(self, a: Self::Item) -> Self::C

where Self::C: GrowableProducer<Self::Item>,

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

type C = Vec<T>

type CC<U> = Vec<U>

type F = [T; N]

type CF<U> = [U; N]

fn unzip<A, B>(self) -> (Self::CF<A>, Self::CF<B>)

where Self: Sized + Iterable<Item = (A, B)>,

Implementors

impl<'a, I, T> Iterable for LazyCloned<I>

where T: 'a + Clone, I: Iterable<Item = &'a T>,

type C = <I as Iterable>::CC<T>

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::CF<T>

type CF<U> = <I as Iterable>::CF<U>

impl<'a, I, T> Iterable for LazyCopied<I>

where T: 'a + Copy, I: Iterable<Item = &'a T>,

type C = <I as Iterable>::CC<T>

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::CF<T>

type CF<U> = <I as Iterable>::CF<U>

impl<I> Iterable for LazyCycle<I>

where I: Iterable, I::IntoIter: Clone,

type C = <I as Iterable>::C

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::C

type CF<U> = <I as Iterable>::CC<U>

impl<I> Iterable for LazyEnumerate<I>

where I: Iterable,

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

type CC<U> = <I as Iterable>::CC<U>

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

type CF<U> = <I as Iterable>::CF<U>

impl<I> Iterable for LazyFlatten<I>

where I: Iterable, I::Item: Consumer,

type C = <I as Iterable>::CC<<<I as Consumer>::Item as Consumer>::Item>

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::CC<<<I as Consumer>::Item as Consumer>::Item>

type CF<U> = <I as Iterable>::CC<U>

impl<I> Iterable for LazyRev<I>

where I: Iterable, I::IntoIter: DoubleEndedIterator,

type C = <I as Iterable>::C

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::F

type CF<U> = <I as Iterable>::CF<U>

impl<I> Iterable for LazySkip<I>

where I: Iterable,

type C = <I as Iterable>::C

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::C

type CF<U> = <I as Iterable>::CC<U>

impl<I> Iterable for LazyStepBy<I>

where I: Iterable,

type C = <I as Iterable>::C

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::C

type CF<U> = <I as Iterable>::CC<U>

impl<I> Iterable for LazyTake<I>

where I: Iterable,

type C = <I as Iterable>::C

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::C

type CF<U> = <I as Iterable>::CC<U>

impl<I, C> Iterable for LazyChain<I, C>

where I: Iterable, C: Consumer<Item = I::Item>,

type C = <I as Iterable>::C

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::C

type CF<U> = <I as Iterable>::CC<U>

impl<I, C> Iterable for LazyZip<I, C>

where I: Iterable, C: Consumer,

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

type CC<U> = <I as Iterable>::CC<U>

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

type CF<U> = <I as Iterable>::CC<U>

impl<I, F> Iterable for LazyFilter<I, F>

where I: Iterable, F: Fn(&I::Item) -> bool,

type C = <I as Iterable>::C

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::C

type CF<U> = <I as Iterable>::CC<U>

impl<I, F> Iterable for LazySkipWhile<I, F>

where I: Iterable, F: Fn(&I::Item) -> bool,

type C = <I as Iterable>::C

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::C

type CF<U> = <I as Iterable>::CC<U>

impl<I, F, T> Iterable for LazyFilterMap<I, F>

where I: Iterable, F: Fn(I::Item) -> Option<T>,

type C = <I as Iterable>::CC<T>

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::CC<T>

type CF<U> = <I as Iterable>::CC<U>

impl<I, F, T> Iterable for LazyFlatMap<I, F>

where I: Iterable, F: Fn(I::Item) -> T, T: Consumer,

type C = <I as Iterable>::CC<<T as Consumer>::Item>

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::CC<<T as Consumer>::Item>

type CF<U> = <I as Iterable>::CC<U>

impl<I, F, T> Iterable for LazyMap<I, F>

where I: Iterable, F: Fn(I::Item) -> T,

type C = <I as Iterable>::CC<T>

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::CF<T>

type CF<U> = <I as Iterable>::CF<U>

impl<I, F, T> Iterable for LazyMapWhile<I, F>

where I: Iterable, F: Fn(I::Item) -> Option<T>,

type C = <I as Iterable>::CC<T>

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::CC<T>

type CF<U> = <I as Iterable>::CC<U>

impl<S, I, F> Iterable for LazyScan<S, I, F>

where S: Clone, I: Iterable, F: Fn(S, I::Item) -> S,

type C = <I as Iterable>::CC<S>

type CC<U> = <I as Iterable>::CC<U>

type F = <I as Iterable>::CC<S>

type CF<U> = <I as Iterable>::CC<U>