Struct Take 

pub struct Take<I: NonEmptyIterator> { /* private fields */ }

Represents non-empty iterators that only iterate over the first given number of items of the underlying iterator.

Implementations

impl<I: NonEmptyIterator> Take<I>

pub const fn new(non_empty: I, count: Size) -> Self

Constructs Self.

Trait Implementations

impl<I: Clone + NonEmptyIterator> Clone for Take<I>

fn clone(&self) -> Take<I>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug + NonEmptyIterator> Debug for Take<I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I: NonEmptyIterator> IntoIterator for Take<I>

type Item = <I as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = Take<<I as IntoIterator>::IntoIter>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<I: NonEmptyIterator> NonEmptyIterator for Take<I>

fn consume(self) -> (Self::Item, Self::IntoIter)

Consumes the non-empty iterator, returning the next item along with the possibly empty iterator.

fn count(self) -> Size

Consumes the non-empty iterator, returning the item count.

fn enumerate(self) -> Enumerate<Self>

Creates non-empty iterators that yield the current count and the item during iteration.

fn peeked(self) -> Peeked<Self::IntoIter>

Peeks at the next item of the non-empty iterator, returning it along with the possibly empty iterator.

fn chain<I: IntoIterator<Item = Self::Item>>( self, other: I, ) -> Chain<Self, I::IntoIter>

Links the non-empty iterator with the provided possibly empty iterator.

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

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

Creates non-empty iterators that clone the items of the underlying non-empty iterator.

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

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

Creates non-empty iterators that copy the items of the underlying non-empty iterator.

fn zip<I: IntoNonEmptyIterator>( self, other: I, ) -> Zip<Self, I::IntoNonEmptyIter>

Zips the non-empty iterator with the provided non-empty iterator.

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

Sums the items of the non-empty iterator together.

fn product<P: Product<Self::Item>>(self) -> P

Multiplies the items of the non-empty iterator together.

fn all<P: FnMut(Self::Item) -> bool>(self, predicate: P) -> bool

Tests whether all items of the non-empty iterator match the predicate.

fn any<P: FnMut(Self::Item) -> bool>(self, predicate: P) -> bool

Tests whether any items of the non-empty iterator match the predicate.

fn none<P: FnMut(Self::Item) -> bool>(self, predicate: P) -> bool

Tests whether no items of the non-empty iterator match the predicate.

fn reduce<F>(self, function: F) -> Self::Item

where F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the items of the non-empty iterator into the single one by repeatedly applying the given function.

fn unzip<T, U, C: Default + Extend<T>, D: Default + Extend<U>>(self) -> (C, D)

where Self: NonEmptyIterator<Item = (T, U)>,

Converts the non-empty iterator of pairs into the pair of collections.

fn collect<C: FromIterator<Self::Item>>(self) -> C

Equivalent to collect on Iterator.

fn collect_non_empty<C: FromNonEmptyIterator<Self::Item>>(self) -> C

Collects the items of the non-empty iterator into the collection.

fn flat_map<J: IntoNonEmptyIterator, F: FnMut(Self::Item) -> J>( self, function: F, ) -> FlatMap<Self, J, F>

Similar to map, but flattens produced non-empty iterators.

fn flatten(self) -> Flatten<Self>

where Self::Item: IntoNonEmptyIterator,

Flattens one level of nesting in self non-empty iterator.

fn filter<P: FnMut(&Self::Item) -> bool>( self, predicate: P, ) -> Filter<Self::IntoIter, P>

Equivalent to filter on Iterator.

fn find<P: FnMut(&Self::Item) -> bool>(self, predicate: P) -> Option<Self::Item>

Equivalent to find on Iterator.

fn filter_map<T, F: FnMut(Self::Item) -> Option<T>>( self, function: F, ) -> FilterMap<Self::IntoIter, F>

Equivalent to filter_map on Iterator.

fn fold<A, F: FnMut(A, Self::Item) -> A>(self, initial: A, function: F) -> A

Equivalent to fold on Iterator.

fn map<U, F: FnMut(Self::Item) -> U>(self, function: F) -> Map<Self, F>

Creates non-empty iterators that map the items of the non-empty iterator with the function.

fn max(self) -> Self::Item

where Self::Item: Ord,

Returns the maximum item of the non-empty iterator.

fn max_by<F: FnMut(&Self::Item, &Self::Item) -> Ordering>( self, function: F, ) -> Self::Item

Returns the maximum item of the non-empty iterator with respect to the comparison function.

fn max_by_key<K: Ord, F: FnMut(&Self::Item) -> K>( self, function: F, ) -> Self::Item

Returns the maximum item of the non-empty iterator with respect to the key function.

fn min(self) -> Self::Item

where Self::Item: Ord,

Returns the minimum item of the non-empty iterator.

fn min_by<F: FnMut(&Self::Item, &Self::Item) -> Ordering>( self, function: F, ) -> Self::Item

Returns the minimum item of the non-empty iterator with respect to the comparison function.

fn min_by_key<K: Ord, F: FnMut(&Self::Item) -> K>( self, function: F, ) -> Self::Item

Returns the minimum item of the non-empty iterator with respect to the key function.

fn nth(self, n: Size) -> Option<Self::Item>

Returns the n-th item of the non-empty iterator.

fn skip(self, count: Size) -> Skip<Self::IntoIter>

Skips the first given number of items in the non-empty iterator.

fn take(self, count: Size) -> Take<Self>

Takes only the first given number of items from the non-empty iterator.

fn last(self) -> Self::Item

Returns the last item of the non-empty iterator.

fn step_by(self, step: Size) -> StepBy<Self>

Steps the non-empty iterator by the given custom amount.

fn for_each<F: FnMut(Self::Item)>(self, function: F)

Equivalent to for_each on Iterator.

fn exhaust(self)

Consumes the iterator, exhausting it by dropping all of its items.

fn skip_while<P: FnMut(&Self::Item) -> bool>( self, predicate: P, ) -> SkipWhile<Self::IntoIter, P>

Equivalent to skip_while on Iterator.

fn take_while<P: FnMut(&Self::Item) -> bool>( self, predicate: P, ) -> TakeWhile<Self::IntoIter, P>

Equivalent to take_while on Iterator.

fn map_while<T, P: FnMut(Self::Item) -> Option<T>>( self, predicate: P, ) -> MapWhile<Self::IntoIter, P>

Equivalent to map_while on Iterator.

fn scan<S, T, F: FnMut(&mut S, Self::Item) -> Option<T>>( self, initial: S, function: F, ) -> Scan<Self::IntoIter, S, F>

Equivalent to scan on Iterator.

fn inspect<F: FnMut(&Self::Item)>(self, function: F) -> Inspect<Self, F>

Creates non-empty iterators that call the provided function with references to each item.

fn partition<C: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool>( self, function: F, ) -> (C, C)

Equivalent to partition on Iterator.

fn position<P: FnMut(Self::Item) -> bool>(self, predicate: P) -> Option<usize>

Equivalent to position on Iterator.

fn cmp<I: IntoIterator<Item = Self::Item>>(self, other: I) -> Ordering

where Self::Item: Ord,

Equivalent to cmp on Iterator.

fn partial_cmp<I: IntoIterator>(self, other: I) -> Option<Ordering>

where Self::Item: PartialOrd<I::Item>,

Equivalent to partial_cmp on Iterator.

fn eq<I: IntoIterator>(self, other: I) -> bool

where Self::Item: PartialEq<I::Item>,

Equivalent to eq on Iterator.

fn ne<I: IntoIterator>(self, other: I) -> bool

where Self::Item: PartialEq<I::Item>,

Equivalent to ne on Iterator.

fn lt<I: IntoIterator>(self, other: I) -> bool

where Self::Item: PartialOrd<I::Item>,

Equivalent to lt on Iterator.

fn le<I: IntoIterator>(self, other: I) -> bool

where Self::Item: PartialOrd<I::Item>,

Equivalent to le on Iterator.

fn gt<I: IntoIterator>(self, other: I) -> bool

where Self::Item: PartialOrd<I::Item>,

Equivalent to gt on Iterator.

fn ge<I: IntoIterator>(self, other: I) -> bool

where Self::Item: PartialOrd<I::Item>,

Equivalent to ge on Iterator.

fn is_sorted(self) -> bool

where Self::Item: PartialOrd,

Equivalent to is_sorted on Iterator.

fn is_sorted_by<F: FnMut(&Self::Item, &Self::Item) -> bool>( self, function: F, ) -> bool

Equivalent to is_sorted_by on Iterator.

fn is_sorted_by_key<K: PartialOrd, F: FnMut(Self::Item) -> K>( self, function: F, ) -> bool

Equivalent to is_sorted_by_key on Iterator.

fn collect_into<C: Extend<Self::Item>>(self, collection: &mut C) -> &mut C

Similar to collect, but extends the provided collection instead of creating new ones.

fn find_map<T, F: FnMut(Self::Item) -> Option<T>>( self, function: F, ) -> Option<T>

Equivalent to find_map on Iterator.

fn fuse(self) -> Fuse<Self>

Fuses the non-empty iterator, ensuring that once it returns None, it will return None forever afterwards.

fn rev(self) -> Rev<Self>

where Self::IntoIter: DoubleEndedIterator,

Reverses the iteration in non-empty iterators.

fn cycle(self) -> Cycle<Self>

where Self::IntoIter: Clone,

Repeats the non-empty iterator endlessly.