[−][src]Trait iterable::Iterable

pub trait Iterable: Consumer {
    type C;
    type CC;
    type F = Self::C;
    type CF = Self::CC;
    type CR;
    type FR = Self::CR;
    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 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 with_filter<F: Fn(&Self::Item) -> bool>(
        self, 
        f: F
    ) -> WithFilter<Self, F>
    where
        Self: Sized,
    { ... }
}

Associated Types

type C

type CC

type F = Self::C

type CF = Self::CC

type CR

type FR = Self::CR

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 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 with_filter<F: Fn(&Self::Item) -> bool>(self, f: F) -> WithFilter<Self, F> where
    Self: Sized, 

Loading content...

Implementations on Foreign Types

impl<'a, I> Iterable for &'a I where
    I: Iterable,
    &'a I: Consumer, [src]

type C = I::CR

type CC = I::CC

type F = I::FR

type CF = I::CF

type CR = I::CR

type FR = I::FR

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

type C = Vec<&'a T>

type CC = Vec<U>

type CR = Vec<&'b T>

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

type C = Self

type CC = Vec<U>

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

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

type C = Self

type CC = HashSet<U>

type CR = HashSet<&'a T>

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

type C = Self

type CC = Vec<U>

type CR = Vec<&'a T>

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

type C = Self

type CC = BTreeSet<U>

type CR = BTreeSet<&'a T>

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

type C = Self

type CC = Vec<U>

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

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

type C = Self

type CC = BinaryHeap<U>

type CR = BinaryHeap<&'a T>

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

type C = Self

type CC = LinkedList<U>

type CR = LinkedList<&'a T>

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

type C = Self

type CC = VecDeque<U>

type CR = VecDeque<&'a T>

impl Iterable for String[src]

type C = Self

type CC = Vec<U>

type CR = String

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

type C = String

type CC = Vec<U>

type CR = String

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]

type CR = Vec<&'a T>

type FR = [&'a T; N]

Loading content...

Implementors

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

type C = I::C

type CC = I::CC

type CR = I::CR

Loading content...