Struct All 

pub struct All<I: Index>(/* private fields */);

The return type of Index::all().

Trait Implementations

impl<I: Clone + Index> Clone for All<I>

where I::Size: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Index> Debug for All<I>

where I::Size: Debug,

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

Formats the value using the given formatter.

impl<I: Index> View for All<I>

type I = I

The index type.

type T = I

The element type.

fn size(&self) -> <Self::I as Index>::Size

The size of the array.

fn at(&self, index: Self::I) -> Self::T

Compute the element at index.

fn len(&self) -> usize

The number of elements in Self.

fn collect<A>(&self) -> A

where A: NewView<I = Self::I, T = Self::T>,

Materialises this View into a collection of type A, e.g. an Array.

fn nested_collect<A>(self, size: <<Self::T as View>::I as Index>::Size) -> A

where Self::T: View, A: NewView<I = (Self::I, <Self::T as View>::I), T = <Self::T as View>::T>,

Materialises this nested View into a collection of type A, e.g. an Array.

fn each(self, f: impl FnMut(Self::T))

Apply f to every element of this View in turn.

fn enumerate(self) -> Enumerate<Self>

Creates a View with the same Index type as self such that at(i) returns (i, self.at(i)).

fn diagonal(self, zero: Self::T) -> Diagonal<Self>

Returns a View that maps (i, i) to t when Self maps i to t. It maps (i, j) to zero if i != j.

fn map<U: Clone, F>(self, f: F) -> Map<Self, F>

where F: Fn(Self::T) -> U,

Creates a View that applies f to the elements of Self.

fn compose<V: View<I = Self::T>>(self, other: V) -> Compose<Self, V>

Creates a View that uses self to select elements of other.

fn concat<V: View<T = Self::T>, I: Index, J: Index>( self, other: V, ) -> Concat<Self, V, I, J>

where Self::I: Isomorphic<(I, usize, J)>, <Self::I as Index>::Size: Isomorphic<(I::Size, usize, J::Size)>, V::I: Isomorphic<(I, usize, J)>, <V::I as Index>::Size: Isomorphic<(I::Size, usize, J::Size)>,

Concatenates self with other along an axis of type usize.

fn from_usize<I: Index, X: Index, J: Index>( self, from_length: impl FnOnce(usize) -> X::Size, ) -> FromUsize<Self, I, X, J>

where Self::I: Isomorphic<(I, usize, J)>, <Self::I as Index>::Size: Isomorphic<<(I, usize, J) as Index>::Size>,

Replace an axis Indexed by usize with one indexed by X.

fn to_usize<I: Index, X: Index, J: Index>(self) -> ToUsize<Self, I, X, J>

where Self::I: Isomorphic<(I, X, J)>, <Self::I as Index>::Size: Isomorphic<<(I, X, J) as Index>::Size>,

Replace an axis Indexed by X with one indexed by usize.

fn insert_one<I: Index, J: Index, K: Index>( self, size: J::Size, ) -> InsertOne<Self, I, J, K>

where Self::I: Isomorphic<(I, K)>, <Self::I as Index>::Size: Isomorphic<(I::Size, K::Size)>,

Insert an axis of type J and length 1.

fn remove_one<I: Index, J: Index, K: Index>(self) -> RemoveOne<Self, I, J, K>

where Self::I: Isomorphic<(I, J, K)>, <Self::I as Index>::Size: Isomorphic<(I::Size, J::Size, K::Size)>,

Remove an axis of type J and length 1.

fn map_axis<I: Index, V: View, J: Index>( self, other: V, ) -> MapAxis<Self, I, V, J>

where V::T: Index, Self::I: Isomorphic<(I, V::T, J)>, <Self::I as Index>::Size: Isomorphic<(I::Size, <V::T as Index>::Size, J::Size)>,

Creates a view such that at((i, x, j)) gives self.at((i, other.at(x), j)).

fn zip<V: View>(self, other: V) -> Zip<Self, V, Pair>

where Self::I: Broadcast<V::I>,

Creates a View that pairs of an element of self and an element of other.

fn binary<V: View, B>(self, other: V) -> Zip<Self, V, B>

where Self::I: Broadcast<V::I>, B: Binary<Self::T, V::T>,

Creates a View that pairs of an element of self and an element of other, then applies binary operator B.

fn coat<I>(self) -> Coat<Self, I>

where I: Coat<Self::I> + Index, Self::I: Coat<I>, I::Size: Coat<<Self::I as Index>::Size>, <Self::I as Index>::Size: Coat<I::Size>,

Wrap some of the Indexes of this View in Coated.

fn iso<J>(self) -> Iso<Self, J>

where J: Isomorphic<Self::I> + Index, J::Size: Isomorphic<<Self::I as Index>::Size>,

Change the index type of this View to an Isomorphic type.

fn transpose<I: Index, X: Index, Y: Index, J: Index>( self, ) -> Transpose<Self, I, X, Y, J>

where (I, (Y, X), J): Isomorphic<Self::I>, (I::Size, (Y::Size, X::Size), J::Size): Isomorphic<<Self::I as Index>::Size>,

Reorder the indices of this View up to Isomorphic.

fn row<I: Index, J: Index>(self, i: I) -> Row<Self, I, J>

where (I, J): Isomorphic<Self::I>, (I::Size, J::Size): Isomorphic<<Self::I as Index>::Size>,

Returns a View whose at(j) returns self.at(i, j).

fn rows<I: Index, J: Index>(&self) -> Rows<&Self, I, J>

where (I, J): Isomorphic<Self::I>, (I::Size, J::Size): Isomorphic<<Self::I as Index>::Size>,

Returns a View whose at(i) returns self.row(i).

fn column<I: Index, J: Index>(self, j: J) -> Column<Self, I, J>

where (I, J): Isomorphic<Self::I>, (I::Size, J::Size): Isomorphic<<Self::I as Index>::Size>,

Returns a View whose at(i) returns self.at(i, j).

fn columns<I: Index, J: Index>(&self) -> Columns<&Self, I, J>

where (I, J): Isomorphic<Self::I>, (I::Size, J::Size): Isomorphic<<Self::I as Index>::Size>,

Returns a View whose at(j) returns self.column(j).

impl<I: Copy + Index> Copy for All<I>

where I::Size: Copy,