Struct hybrid_array::Array

#[repr(transparent)]
pub struct Array<T, U: ArraySize>(pub U::ArrayType<T>);

Hybrid typenum-based and const generic array type.

Provides the flexibility of typenum-based expressions while also allowing interoperability and a transition path to const generics.

Tuple Fields

0: U::ArrayType<T>

Implementations

impl<T, U> Array<T, U>where U: ArraySize,

pub fn from_fn<F>(cb: F) -> Selfwhere F: FnMut(usize) -> T,

Create array where each array element T is returned by the cb call.

pub fn from_slice(slice: &[T]) -> Result<Self, TryFromSliceError>where T: Copy,

Create array from a slice.

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

pub fn ref_from_slice(slice: &[T]) -> &Self

Convert the given slice into a reference to a hybrid array.

Panics

Panics if the slice’s length doesn’t match the array type.

pub fn ref_from_mut_slice(slice: &mut [T]) -> &mut Self

Convert the given mutable slice to a mutable reference to a hybrid array.

Panics

Panics if the slice’s length doesn’t match the array type.

pub fn clone_from_slice(slice: &[T]) -> Selfwhere Self: Clone,

Clone the contents of the slice as a new hybrid array.

Panics

Panics if the slice’s length doesn’t match the array type.

Trait Implementations

impl<T> ArrayOps<T, 0> for Array<T, U0>

const SIZE: usize = 0usize

Size of an array as a usize.

type Size = UTerm

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 0]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 0]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 0]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 0]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 0]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 0]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 1> for Array<T, U1>

const SIZE: usize = 1usize

Size of an array as a usize.

type Size = UInt<UTerm, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 1]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 1]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 1]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 1]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 1]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 1]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 10> for Array<T, U10>

const SIZE: usize = 10usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 10]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 10]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 10]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 10]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 10]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 10]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 1024> for Array<T, U1024>

const SIZE: usize = 1_024usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 1024]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 1024]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 1024]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 1024]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 1024]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 1024]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 11> for Array<T, U11>

const SIZE: usize = 11usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 11]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 11]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 11]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 11]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 11]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 11]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 12> for Array<T, U12>

const SIZE: usize = 12usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 12]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 12]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 12]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 12]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 12]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 12]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 128> for Array<T, U128>

const SIZE: usize = 128usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 128]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 128]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 128]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 128]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 128]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 128]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 13> for Array<T, U13>

const SIZE: usize = 13usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 13]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 13]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 13]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 13]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 13]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 13]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 14> for Array<T, U14>

const SIZE: usize = 14usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 14]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 14]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 14]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 14]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 14]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 14]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 15> for Array<T, U15>

const SIZE: usize = 15usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 15]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 15]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 15]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 15]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 15]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 15]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 16> for Array<T, U16>

const SIZE: usize = 16usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 16]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 16]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 16]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 16]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 16]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 16]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 17> for Array<T, U17>

const SIZE: usize = 17usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 17]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 17]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 17]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 17]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 17]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 17]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 18> for Array<T, U18>

const SIZE: usize = 18usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 18]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 18]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 18]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 18]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 18]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 18]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 19> for Array<T, U19>

const SIZE: usize = 19usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 19]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 19]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 19]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 19]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 19]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 19]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 192> for Array<T, U192>

const SIZE: usize = 192usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 192]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 192]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 192]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 192]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 192]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 192]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 2> for Array<T, U2>

const SIZE: usize = 2usize

Size of an array as a usize.

type Size = UInt<UInt<UTerm, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 2]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 2]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 2]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 2]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 2]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 2]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 20> for Array<T, U20>

const SIZE: usize = 20usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 20]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 20]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 20]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 20]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 20]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 20]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 2048> for Array<T, U2048>

const SIZE: usize = 2_048usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 2048]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 2048]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 2048]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 2048]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 2048]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 2048]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 21> for Array<T, U21>

const SIZE: usize = 21usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 21]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 21]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 21]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 21]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 21]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 21]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 22> for Array<T, U22>

const SIZE: usize = 22usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 22]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 22]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 22]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 22]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 22]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 22]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 23> for Array<T, U23>

const SIZE: usize = 23usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 23]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 23]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 23]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 23]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 23]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 23]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 24> for Array<T, U24>

const SIZE: usize = 24usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 24]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 24]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 24]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 24]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 24]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 24]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 25> for Array<T, U25>

const SIZE: usize = 25usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 25]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 25]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 25]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 25]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 25]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 25]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 256> for Array<T, U256>

const SIZE: usize = 256usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 256]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 256]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 256]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 256]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 256]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 256]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 26> for Array<T, U26>

const SIZE: usize = 26usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 26]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 26]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 26]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 26]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 26]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 26]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 27> for Array<T, U27>

const SIZE: usize = 27usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 27]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 27]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 27]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 27]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 27]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 27]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 28> for Array<T, U28>

const SIZE: usize = 28usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 28]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 28]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 28]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 28]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 28]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 28]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 29> for Array<T, U29>

const SIZE: usize = 29usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 29]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 29]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 29]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 29]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 29]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 29]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 3> for Array<T, U3>

const SIZE: usize = 3usize

Size of an array as a usize.

type Size = UInt<UInt<UTerm, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 3]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 3]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 3]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 3]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 3]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 3]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 30> for Array<T, U30>

const SIZE: usize = 30usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 30]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 30]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 30]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 30]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 30]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 30]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 31> for Array<T, U31>

const SIZE: usize = 31usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 31]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 31]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 31]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 31]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 31]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 31]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 32> for Array<T, U32>

const SIZE: usize = 32usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 32]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 32]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 32]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 32]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 32]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 32]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 33> for Array<T, U33>

const SIZE: usize = 33usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 33]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 33]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 33]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 33]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 33]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 33]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 34> for Array<T, U34>

const SIZE: usize = 34usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 34]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 34]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 34]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 34]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 34]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 34]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 35> for Array<T, U35>

const SIZE: usize = 35usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 35]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 35]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 35]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 35]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 35]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 35]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 36> for Array<T, U36>

const SIZE: usize = 36usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 36]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 36]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 36]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 36]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 36]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 36]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 37> for Array<T, U37>

const SIZE: usize = 37usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 37]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 37]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 37]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 37]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 37]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 37]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 38> for Array<T, U38>

const SIZE: usize = 38usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 38]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 38]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 38]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 38]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 38]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 38]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 384> for Array<T, U384>

const SIZE: usize = 384usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 384]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 384]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 384]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 384]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 384]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 384]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 39> for Array<T, U39>

const SIZE: usize = 39usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 39]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 39]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 39]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 39]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 39]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 39]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 4> for Array<T, U4>

const SIZE: usize = 4usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UTerm, B1>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 4]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 4]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 4]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 4]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 4]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 4]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 40> for Array<T, U40>

const SIZE: usize = 40usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 40]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 40]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 40]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 40]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 40]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 40]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 4096> for Array<T, U4096>

const SIZE: usize = 4_096usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 4096]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 4096]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 4096]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 4096]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 4096]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 4096]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 41> for Array<T, U41>

const SIZE: usize = 41usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 41]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 41]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 41]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 41]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 41]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 41]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 42> for Array<T, U42>

const SIZE: usize = 42usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 42]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 42]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 42]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 42]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 42]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 42]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 43> for Array<T, U43>

const SIZE: usize = 43usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 43]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 43]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 43]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 43]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 43]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 43]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 44> for Array<T, U44>

const SIZE: usize = 44usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 44]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 44]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 44]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 44]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 44]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 44]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 448> for Array<T, U448>

const SIZE: usize = 448usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 448]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 448]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 448]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 448]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 448]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 448]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 45> for Array<T, U45>

const SIZE: usize = 45usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 45]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 45]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 45]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 45]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 45]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 45]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 46> for Array<T, U46>

const SIZE: usize = 46usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 46]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 46]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 46]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 46]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 46]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 46]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 47> for Array<T, U47>

const SIZE: usize = 47usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 47]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 47]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 47]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 47]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 47]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 47]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 48> for Array<T, U48>

const SIZE: usize = 48usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 48]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 48]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 48]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 48]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 48]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 48]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 49> for Array<T, U49>

const SIZE: usize = 49usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 49]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 49]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 49]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 49]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 49]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 49]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 5> for Array<T, U5>

const SIZE: usize = 5usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UTerm, B1>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 5]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 5]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 5]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 5]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 5]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 5]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 50> for Array<T, U50>

const SIZE: usize = 50usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 50]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 50]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 50]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 50]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 50]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 50]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 51> for Array<T, U51>

const SIZE: usize = 51usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 51]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 51]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 51]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 51]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 51]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 51]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 512> for Array<T, U512>

const SIZE: usize = 512usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 512]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 512]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 512]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 512]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 512]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 512]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 52> for Array<T, U52>

const SIZE: usize = 52usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 52]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 52]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 52]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 52]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 52]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 52]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 53> for Array<T, U53>

const SIZE: usize = 53usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 53]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 53]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 53]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 53]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 53]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 53]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 54> for Array<T, U54>

const SIZE: usize = 54usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 54]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 54]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 54]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 54]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 54]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 54]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 55> for Array<T, U55>

const SIZE: usize = 55usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 55]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 55]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 55]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 55]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 55]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 55]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 56> for Array<T, U56>

const SIZE: usize = 56usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 56]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 56]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 56]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 56]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 56]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 56]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 57> for Array<T, U57>

const SIZE: usize = 57usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 57]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 57]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 57]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 57]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 57]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 57]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 58> for Array<T, U58>

const SIZE: usize = 58usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 58]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 58]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 58]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 58]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 58]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 58]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 59> for Array<T, U59>

const SIZE: usize = 59usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 59]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 59]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 59]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 59]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 59]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 59]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 6> for Array<T, U6>

const SIZE: usize = 6usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UTerm, B1>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 6]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 6]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 6]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 6]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 6]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 6]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 60> for Array<T, U60>

const SIZE: usize = 60usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 60]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 60]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 60]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 60]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 60]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 60]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 61> for Array<T, U61>

const SIZE: usize = 61usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 61]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 61]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 61]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 61]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 61]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 61]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 62> for Array<T, U62>

const SIZE: usize = 62usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 62]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 62]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 62]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 62]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 62]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 62]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 63> for Array<T, U63>

const SIZE: usize = 63usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 63]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 63]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 63]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 63]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 63]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 63]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 64> for Array<T, U64>

const SIZE: usize = 64usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 64]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 64]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 64]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 64]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 64]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 64]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 7> for Array<T, U7>

const SIZE: usize = 7usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UTerm, B1>, B1>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 7]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 7]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 7]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 7]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 7]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 7]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 768> for Array<T, U768>

const SIZE: usize = 768usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 768]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 768]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 768]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 768]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 768]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 768]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 8> for Array<T, U8>

const SIZE: usize = 8usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 8]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 8]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 8]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 8]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 8]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 8]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 8192> for Array<T, U8192>

const SIZE: usize = 8_192usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 8192]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 8192]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 8192]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 8192]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 8192]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 8192]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 896> for Array<T, U896>

const SIZE: usize = 896usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 896]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 896]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 896]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 896]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 896]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 896]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 9> for Array<T, U9>

const SIZE: usize = 9usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 9]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 9]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 9]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 9]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 9]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 9]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T> ArrayOps<T, 96> for Array<T, U96>

const SIZE: usize = 96usize

Size of an array as a usize.

type Size = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>

ArraySize type: typenum-provided Unsigned integer.

fn as_array_ref(&self) -> &[T; 96]

Returns a reference to the inner array.

fn as_array_mut(&mut self) -> &mut [T; 96]

Returns a mutable reference to the inner array.

fn from_core_array(arr: [T; 96]) -> Self

Create array from Rust’s core array type.

fn from_core_array_ref(array_ref: &[T; 96]) -> &Self

Create array reference from reference to Rust’s core array type.

fn from_core_array_mut(array_ref: &mut [T; 96]) -> &mut Self

Create mutable array reference from reference to Rust’s core array type.

fn map<F, U>(self, f: F) -> [U; 96]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

impl<T, U, const N: usize> AsMut<[T; N]> for Array<T, U>where Self: ArrayOps<T, N>, U: ArraySize,

fn as_mut(&mut self) -> &mut [T; N]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, U, const N: usize> AsRef<[T; N]> for Array<T, U>where Self: ArrayOps<T, N>, U: ArraySize,

fn as_ref(&self) -> &[T; N]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, U, const N: usize> Borrow<[T; N]> for Array<T, U>where Self: ArrayOps<T, N>, U: ArraySize,

fn borrow(&self) -> &[T; N]

Immutably borrows from an owned value.

impl<T, U, const N: usize> BorrowMut<[T; N]> for Array<T, U>where Self: ArrayOps<T, N>, U: ArraySize,

fn borrow_mut(&mut self) -> &mut [T; N]

Mutably borrows from an owned value.

impl<T: Clone, U: Clone + ArraySize> Clone for Array<T, U>where U::ArrayType<T>: Clone,

fn clone(&self) -> Array<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, U: Debug + ArraySize> Debug for Array<T, U>where U::ArrayType<T>: Debug,

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

Formats the value using the given formatter.

impl<T, U> Default for Array<T, U>where T: Default, U: ArraySize,

fn default() -> Self

Returns the “default value” for a type.

impl<T, U> Deref for Array<T, U>where U: ArraySize,

type Target = <U as ArraySize>::ArrayType<T>

The resulting type after dereferencing.

fn deref(&self) -> &U::ArrayType<T>

Dereferences the value.

impl<T, U> DerefMut for Array<T, U>where U: ArraySize,

fn deref_mut(&mut self) -> &mut U::ArrayType<T>

Mutably dereferences the value.

impl<'a, T, U, const N: usize> From<&'a [T; N]> for &'a Array<T, U>where Array<T, U>: ArrayOps<T, N>, U: ArraySize,

fn from(array_ref: &'a [T; N]) -> &'a Array<T, U>

Converts to this type from the input type.

impl<'a, T, U, const N: usize> From<&'a mut [T; N]> for &'a mut Array<T, U>where Array<T, U>: ArrayOps<T, N>, U: ArraySize,

fn from(array_ref: &'a mut [T; N]) -> &'a mut Array<T, U>

Converts to this type from the input type.

impl<T, U, const N: usize> From<[T; N]> for Array<T, U>where Self: ArrayOps<T, N>, U: ArraySize,

fn from(arr: [T; N]) -> Array<T, U>

Converts to this type from the input type.

impl<T: Hash, U: Hash + ArraySize> Hash for Array<T, U>where U::ArrayType<T>: Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, I, U> Index<I> for Array<T, U>where [T]: Index<I>, U: ArraySize,

type Output = <[T] as Index<I>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, I, U> IndexMut<I> for Array<T, U>where [T]: IndexMut<I>, U: ArraySize,

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a Array<T, U0>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U1>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U10>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U1024>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U11>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U12>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U128>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U13>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U14>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U15>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U16>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U17>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U18>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U19>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U192>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U2>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U20>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U2048>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U21>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U22>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U23>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U24>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U25>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U256>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U26>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U27>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U28>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U29>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U3>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U30>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U31>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U32>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U33>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U34>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U35>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U36>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U37>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U38>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U384>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U39>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U4>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U40>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U4096>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U41>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U42>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U43>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U44>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U448>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U45>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U46>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U47>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U48>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U49>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U5>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U50>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U51>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U512>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U52>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U53>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U54>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U55>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U56>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U57>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U58>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U59>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U6>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U60>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U61>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U62>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U63>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U64>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U7>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U768>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U8>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U8192>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U896>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U9>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Array<T, U96>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U0>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U1>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U10>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U1024>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U11>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U12>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U128>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U13>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U14>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U15>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U16>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U17>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U18>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U19>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U192>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U2>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U20>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U2048>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U21>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U22>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U23>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U24>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U25>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U256>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U26>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U27>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U28>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U29>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U3>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U30>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U31>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U32>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U33>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U34>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U35>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U36>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U37>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U38>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U384>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U39>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U4>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U40>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U4096>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U41>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U42>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U43>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U44>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U448>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U45>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U46>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U47>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U48>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U49>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U5>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U50>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U51>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U512>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U52>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U53>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U54>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U55>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U56>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U57>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U58>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U59>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U6>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U60>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U61>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U62>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U63>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U64>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U7>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U768>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U8>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U8192>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U896>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U9>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Array<T, U96>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<T> IntoIterator for Array<T, U0>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 0>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U1>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 1>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U10>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 10>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U1024>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 1024>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U11>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 11>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U12>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 12>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U128>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 128>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U13>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 13>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U14>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 14>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U15>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 15>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U16>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 16>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U17>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 17>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U18>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 18>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U19>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 19>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U192>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 192>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U2>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 2>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U20>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 20>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U2048>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 2048>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U21>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 21>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U22>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 22>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U23>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 23>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U24>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 24>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U25>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 25>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U256>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 256>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U26>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 26>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U27>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 27>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U28>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 28>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U29>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 29>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U3>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 3>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U30>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 30>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U31>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 31>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U32>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 32>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U33>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 33>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U34>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 34>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U35>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 35>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U36>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 36>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U37>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 37>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U38>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 38>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U384>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 384>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U39>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 39>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U4>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 4>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U40>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 40>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U4096>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 4096>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U41>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 41>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U42>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 42>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U43>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 43>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U44>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 44>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U448>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 448>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U45>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 45>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U46>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 46>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U47>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 47>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U48>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 48>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U49>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 49>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U5>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 5>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U50>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 50>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U51>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 51>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U512>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 512>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U52>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 52>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U53>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 53>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U54>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 54>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U55>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 55>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U56>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 56>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U57>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 57>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U58>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 58>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U59>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 59>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U6>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 6>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U60>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 60>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U61>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 61>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U62>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 62>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U63>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 63>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U64>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 64>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U7>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 7>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U768>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 768>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U8>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 8>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U8192>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 8192>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U896>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 896>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U9>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 9>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Array<T, U96>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, 96>

Which kind of iterator are we turning this into?

impl<T: Ord, U: Ord + ArraySize> Ord for Array<T, U>where U::ArrayType<T>: Ord,

fn cmp(&self, other: &Array<T, U>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<T: PartialEq, U: PartialEq + ArraySize> PartialEq<Array<T, U>> for Array<T, U>where U::ArrayType<T>: PartialEq,

fn eq(&self, other: &Array<T, U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd, U: PartialOrd + ArraySize> PartialOrd<Array<T, U>> for Array<T, U>where U::ArrayType<T>: PartialOrd,

fn partial_cmp(&self, other: &Array<T, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, T, U> TryFrom<&'a [T]> for &'a Array<T, U>where U: ArraySize,

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &'a [T]) -> Result<Self, TryFromSliceError>

Performs the conversion.

impl<'a, T, U> TryFrom<&'a [T]> for Array<T, U>where T: Copy, U: ArraySize,

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &'a [T]) -> Result<Array<T, U>, TryFromSliceError>

Performs the conversion.

impl<'a, T, U> TryFrom<&'a mut [T]> for &'a mut Array<T, U>where U: ArraySize,

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &'a mut [T]) -> Result<Self, TryFromSliceError>

Performs the conversion.

impl<T: Copy, U: Copy + ArraySize> Copy for Array<T, U>where U::ArrayType<T>: Copy,

impl<T: Eq, U: Eq + ArraySize> Eq for Array<T, U>where U::ArrayType<T>: Eq,

impl<T, U: ArraySize> StructuralEq for Array<T, U>

impl<T, U: ArraySize> StructuralPartialEq for Array<T, U>