Trait iterable::IterableSeq

pub trait IterableSeq: Iterable {
    fn rev(self) -> Self::F
    where
        Self: Sized,
        Self::F: Producer<Self::Item>,
        Self::IntoIter: DoubleEndedIterator,
    { ... }
    fn sorted(self) -> Self::F
    where
        Self: Sized,
        Self::Item: Ord,
        Self::F: Producer<Self::Item>,
    { ... }
    fn sorted_by<F>(self, f: F) -> Self::F
    where
        F: Fn(&Self::Item, &Self::Item) -> Ordering,
        Self: Sized,
        Self::F: Producer<Self::Item>,
    { ... }
    fn sorted_by_key<K, F>(self, f: F) -> Self::F
    where
        K: Ord,
        F: Fn(&Self::Item) -> K,
        Self: Sized,
        Self::F: Producer<Self::Item>,
    { ... }
    fn lazy_rev(self) -> LazyRev<Self>
    where
        Self: Sized,
        Self::IntoIter: DoubleEndedIterator,
    { ... }
}

Provided methods

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

fn sorted(self) -> Self::F where
    Self: Sized,
    Self::Item: Ord,
    Self::F: Producer<Self::Item>, 

fn sorted_by<F>(self, f: F) -> Self::F where
    F: Fn(&Self::Item, &Self::Item) -> Ordering,
    Self: Sized,
    Self::F: Producer<Self::Item>, 

fn sorted_by_key<K, F>(self, f: F) -> Self::F where
    K: Ord,
    F: Fn(&Self::Item) -> K,
    Self: Sized,
    Self::F: Producer<Self::Item>, 

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

Loading content...

Implementations on Foreign Types

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

impl<T> IterableSeq for LinkedList<T>

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

impl<T> IterableSeq for VecDeque<T>

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

impl IterableSeq for String

impl<'a> IterableSeq for &'a String

impl<'a> IterableSeq for &'a str

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

fn sorted(self) -> Self::F where
    T: Ord, 

fn sorted_by<F>(self, f: F) -> Self::F where
    F: Fn(&Self::Item, &Self::Item) -> Ordering, 

fn sorted_by_key<K, F>(self, f: F) -> Self::F where
    K: Ord,
    F: Fn(&Self::Item) -> K, 

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

impl<T> IterableSeq for Vec<T>

fn rev(self) -> Self::F

fn sorted(self) -> Self::F where
    T: Ord, 

fn sorted_by<F>(self, f: F) -> Self::F where
    F: Fn(&Self::Item, &Self::Item) -> Ordering, 

fn sorted_by_key<K, F>(self, f: F) -> Self::F where
    K: Ord,
    F: Fn(&Self::Item) -> K, 

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

Loading content...

Implementors

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...