Trait iterable::Iterable

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


Show 72 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§

Provided Methods§

Implementations on Foreign Types§

Implementors§