Struct ChainedCol

pub struct ChainedCol<I1, I2, E1, E2>
where
    I1: Collection,
    I2: Collection<Item = I1::Item>,
    E1: SoM<I1>,
    E2: SoM<I2>,
{ /* private fields */ }

An iterable collection created by chaining two iterable collections.

Trait Implementations

impl<I1, I2, E1, E2> Collection for ChainedCol<I1, I2, E1, E2>

where I1: Collection, I2: Collection<Item = I1::Item>, E1: SoM<I1>, E2: SoM<I2>,

type Item = <I1 as Collection>::Item

Type of elements stored by the collection.

type Iterable<'i> = &'i ChainedCol<I1, I2, E1, E2> where Self: 'i

Related type implementing Iterable trait that the as_iterable method returns. If the type of the Collection is X, the corresponding Iterable type is almost always &X due to the following relation among the both traits.

fn as_iterable(&self) -> Self::Iterable<'_>

Returns the corresponding Iterable type of this collection, which is often nothing but &Self.

fn iter(&self) -> <Self::Iterable<'_> as Iterable>::Iter

Creates a new iterator yielding references to the elements of the collection; i.e., type of elements is &Collection::Item.

fn into_chained<I>(self, other: I) -> ChainedCol<Self, I, Self, I>

where Self: Sized, I: Collection<Item = Self::Item>,

Consumes this collection and other; creates an iterable collection which is a chain of these two collections.

fn into_filtered<P>(self, filter: P) -> FilteredCol<Self, Self, P>

where Self: Sized, P: Fn(&Self::Item) -> bool + Copy,

Consumes this collection and creates an iterable collection which is a filtered version of this collection.

fn into_flattened(self) -> FlattenedCol<Self, Self>

where Self: Sized, Self::Item: IntoIterator, for<'i> &'i Self::Item: IntoIterator<Item = &'i <Self::Item as IntoIterator>::Item>,

Consumes this collection and creates an iterable collection which is a flattened version of this collection.

fn into_fused(self) -> FusedCol<Self, Self>

where Self: Sized,

Consumes this collection and creates an iterable collection which is a fused version of this collection.

fn into_reversed(self) -> ReversedCol<Self, Self>

where Self: Sized, for<'b> <Self::Iterable<'b> as Iterable>::Iter: DoubleEndedIterator,

Consumes this collection and creates an iterable collection which is a reversed version of this collection.

fn into_skipped(self, n: usize) -> SkippedCol<Self, Self>

where Self: Sized,

Consumes this collection and creates an iterable collection which is skipped-by-n version of this collection.

fn into_skipped_while<P>(self, skip_while: P) -> SkippedWhileCol<Self, Self, P>

where Self: Sized, P: Fn(&Self::Item) -> bool + Copy,

Consumes this collection and creates an iterable collection which is skipped-while version of this collection.

fn into_stepped_by(self, step: usize) -> SteppedByCol<Self, Self>

where Self: Sized,

Consumes this collection and creates an iterable collection which is stepped-by-step version of this collection.

fn into_taken(self, n: usize) -> TakenCol<Self, Self>

where Self: Sized,

Consumes this collection and creates an iterable collection which is taken-n version of this collection.

fn into_taken_while<P>(self, take_while: P) -> TakenWhileCol<Self, Self, P>

where Self: Sized, P: Fn(&Self::Item) -> bool + Copy,

Consumes this collection and creates an iterable collection which is taken-while version of this collection.

impl<I1, I2, E1, E2> CollectionMut for ChainedCol<I1, I2, E1, E2>

where I1: CollectionMut, I2: CollectionMut<Item = I1::Item>, E1: SoM<I1>, E2: SoM<I2>,

type IterMut<'i> = Chain<<I1 as CollectionMut>::IterMut<'i>, <I2 as CollectionMut>::IterMut<'i>> where Self: 'i

Type of the iterator yielding mutable references created by the iter_mut method.

fn iter_mut(&mut self) -> Self::IterMut<'_>

Creates a new iterator yielding mutable references to the elements of the collection; i.e., type of elements is &mut Collection::Item.

fn chained_mut<'a, I>( &'a mut self, other: &'a mut I, ) -> ChainedCol<Self, I, &'a mut Self, &'a mut I>

where Self: Sized, I: CollectionMut<Item = Self::Item>,

Combines mutable references of this collection and other; and creates an iterable collection which is a chain of these two collections.

fn filtered_mut<P>(&mut self, filter: P) -> FilteredCol<Self, &mut Self, P>

where Self: Sized, P: Fn(&Self::Item) -> bool + Copy,

Creates an iterable collection view which is a filtered version of this collection from its mutable reference.

fn flattened_mut(&mut self) -> FlattenedCol<Self, &mut Self>

where Self: Sized, Self::Item: IntoIterator, for<'i> &'i Self::Item: IntoIterator<Item = &'i <Self::Item as IntoIterator>::Item>, for<'i> &'i mut Self::Item: IntoIterator<Item = &'i mut <Self::Item as IntoIterator>::Item>,

Creates an iterable collection view which is a flattened version of this collection from its mutable reference.

fn fused_mut(&mut self) -> FusedCol<Self, &mut Self>

where Self: Sized,

Creates an iterable collection view which is a fused version of this collection from its mutable reference.

fn reversed_mut(&mut self) -> ReversedCol<Self, &mut Self>

where Self: Sized, for<'b> <Self::Iterable<'b> as Iterable>::Iter: DoubleEndedIterator, for<'b> Self::IterMut<'b>: DoubleEndedIterator,

Creates an iterable collection view which is a reversed version of this collection from its mutable reference.

fn skipped_mut(&mut self, n: usize) -> SkippedCol<Self, &mut Self>

where Self: Sized,

Creates an iterable collection view which is skipped-by-n version of this collection from its mutable reference.

fn skipped_while_mut<P>( &mut self, skip_while: P, ) -> SkippedWhileCol<Self, &mut Self, P>

where Self: Sized, P: Fn(&Self::Item) -> bool + Copy,

Creates an iterable collection view which is skipped-while version of this collection from its mutable reference.

fn stepped_by_mut(&mut self, step: usize) -> SteppedByCol<Self, &mut Self>

where Self: Sized,

Creates an iterable collection view which is stepped-by-step version of this collection from its mutable reference.

fn taken_mut(&mut self, n: usize) -> TakenCol<Self, &mut Self>

where Self: Sized,

Creates an iterable collection view which is taken-n version of this collection from its mutable reference.

fn taken_while_mut<P>( &mut self, take_while: P, ) -> TakenWhileCol<Self, &mut Self, P>

where Self: Sized, P: Fn(&Self::Item) -> bool + Copy,

Creates an iterable collection view which is taken-while version of this collection from its mutable reference.

impl<I1, I2, E1, E2> CollectionMutObj for ChainedCol<I1, I2, E1, E2>

where I1: CollectionMut, I2: CollectionMut<Item = <I1 as Collection>::Item>, E1: SoM<I1>, E2: SoM<I2>,

fn boxed_iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut Self::Item> + '_>

Creates a new iterator in a box yielding mutable references to the elements of the collection; i.e., type of elements is &mut Item.

impl<I1, I2, E1, E2> CollectionObj for ChainedCol<I1, I2, E1, E2>

where I1: Collection, I2: Collection<Item = <I1 as Collection>::Item>, E1: SoM<I1>, E2: SoM<I2>,

type Item = <I1 as Collection>::Item

Type of elements stored by the collection.

fn boxed_iter(&self) -> Box<dyn Iterator<Item = &Self::Item> + '_>

Creates a new iterator in a box yielding references to the elements of the collection; i.e., type of elements is &Item.

impl<'a, I1, I2, E1, E2> Iterable for &'a ChainedCol<I1, I2, E1, E2>

where I1: Collection, I2: Collection<Item = I1::Item>, E1: SoM<I1>, E2: SoM<I2>,

type Item = &'a <I1 as Collection>::Item

Type of the item that the iterators created by the iter method yields.

type Iter = Chain<<<I1 as Collection>::Iterable<'a> as Iterable>::Iter, <<I2 as Collection>::Iterable<'a> as Iterable>::Iter>

Type of the iterator created by the iter method.

fn iter(&self) -> Self::Iter

Creates a new iterator from this iterable yielding elements of type Iterable::Item.

fn chained<I>(self, other: I) -> Chained<Self, I>

where Self: Sized, I: Iterable<Item = Self::Item>,

Takes two iterables and creates a new iterable over both in sequence.

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

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

Creates an iterable, iterators of which clone all of its elements.

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

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

Creates an iterable, iterators of which copy all of its elements.

fn enumerated(self) -> Enumerated<Self>

where Self: Sized,

Creates an iterable which gives the current iteration count as well as the next value.

fn filter_mapped<M, U>(self, filter_map: M) -> FilterMapped<Self, M, U>

where Self: Sized, M: Fn(Self::Item) -> Option<U> + Copy,

Creates an iterable that both filters and maps.

fn filtered<P>(self, filter: P) -> Filtered<Self, P>

where Self: Sized, P: Fn(&Self::Item) -> bool + Copy,

Creates an iterable which uses a closure to determine if an element should be yielded.

fn flat_mapped<M, U>(self, flat_map: M) -> FlatMapped<Self, M, U>

where Self: Sized, U: IntoIterator, M: Fn(Self::Item) -> U + Copy,

Creates an iterable that works like map, but flattens nested structure.

fn flattened(self) -> Flattened<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterable that flattens nested structure.

fn fused(self) -> Fused<Self>

where Self: Sized,

Creates an iterable which ends after the first None.

fn mapped_while<M, U>(self, map_while: M) -> MappedWhile<Self, M, U>

where Self: Sized, M: Fn(Self::Item) -> Option<U> + Copy,

Creates an iterable that both yields elements based on a predicate and maps.

fn mapped<M, U>(self, map: M) -> Mapped<Self, M, U>

where Self: Sized, M: Fn(Self::Item) -> U + Copy,

Takes a closure and creates an iterable which calls that closure on each element.

fn reversed(self) -> Reversed<Self>

where Self: Sized, Self::Iter: DoubleEndedIterator,

Creates an iterable iterators of which reverses the traversal direction.

fn skipped(self, n: usize) -> Skipped<Self>

where Self: Sized,

Creates an iterable, iterators of which skip the first n elements.

fn skipped_while<P>(self, skip_while: P) -> SkippedWhile<Self, P>

where Self: Sized, P: Fn(&Self::Item) -> bool + Copy,

Creates an iterable, iterators of which skip elements based on a predicate.

fn stepped_by(self, step: usize) -> SteppedBy<Self>

where Self: Sized,

Creates an iterable starting at the same point, but stepping by the given amount at each iteration.

fn taken(self, n: usize) -> Taken<Self>

where Self: Sized,

Creates an iterable whose iterators yield the first n elements, or fewer if the underlying iterator ends sooner.

fn taken_while<P>(self, take_while: P) -> TakenWhile<Self, P>

where Self: Sized, P: Fn(&Self::Item) -> bool + Copy,

Creates an iterable, iterators of which yield elements based on a predicate.

fn zipped<I>(self, other: I) -> Zipped<Self, I>

where Self: Sized, I: Iterable,

‘Zips up’ two iterables into a single iterable of pairs.

impl<'a, I1, I2, E1, E2> IterableObj for &'a ChainedCol<I1, I2, E1, E2>

where I1: Collection, I2: Collection<Item = <I1 as Collection>::Item>, E1: SoM<I1>, E2: SoM<I2>,

type Item = &'a <I1 as Collection>::Item

Type of the item that the iterators created by the boxed_iter method yields.

fn boxed_iter(&self) -> Box<dyn Iterator<Item = Self::Item> + '_>

Creates a new iterator in a box from this iterable yielding elements of type IterableObj::Item.