Struct hybrid_array::Array

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

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

Implementations

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

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[..].

Trait Implementations

impl<T> ArrayOps<T, 0_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 1024_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 10_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 11_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 128_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 12_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 13_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 14_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 15_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 16_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 17_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 18_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 192_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 19_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 1_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 2048_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 20_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 21_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 22_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 23_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 24_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 256_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 25_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 26_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 27_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 28_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 29_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 2_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 30_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 31_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 32_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 33_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 34_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 35_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 36_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 37_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 384_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 38_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 39_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 3_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 4096_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 40_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 41_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 42_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 43_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 448_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 44_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 45_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 46_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 47_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 48_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 49_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 4_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 50_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 512_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 51_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 52_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 53_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 54_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 55_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 56_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 57_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 58_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 59_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 5_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 60_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 61_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 62_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 63_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 64_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 6_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 768_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 7_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 8192_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 896_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 8_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 96_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T> ArrayOps<T, 9_usize> 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_slice(slice: &[T]) -> Result<Self, TryFromSliceError> where
    T: Copy, 

Create array from a slice.

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.

fn from_fn<F>(cb: F) -> Self where
    F: FnMut(usize) -> T, 

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

fn iter(&self) -> Iter<'_, T>

Returns an iterator over the array.

fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

impl<T, U, const N: usize> AsMut<[T; N]> for Array<T, U> where
    Self: ArrayOps<T, N>,
    U: ArraySize<T>, 

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<T>, 

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<T>, 

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<T>, 

fn borrow_mut(&mut self) -> &mut [T; N]

Mutably borrows from an owned value.

impl<T: Clone, U: Clone + ArraySize<T>> Clone for Array<T, U> where
    U::ArrayType: 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<T>> Debug for Array<T, U> where
    U::ArrayType: Debug, 

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

Formats the value using the given formatter.

impl<T, U, const N: usize> From<[T; N]> for Array<T, U> where
    Self: ArrayOps<T, N>,
    U: ArraySize<T>, 

fn from(arr: [T; N]) -> Array<T, U>

Converts to this type from the input type.

impl<T: Hash, U: Hash + ArraySize<T>> Hash for Array<T, U> where
    U::ArrayType: 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, 

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<T>, 

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<T>, 

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

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_usize>

Which kind of iterator are we turning this into?

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, 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, 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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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, 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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, 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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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, 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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, 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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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, 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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, 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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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, 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, 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_usize>

Which kind of iterator are we turning this into?

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 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, 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, 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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, 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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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, 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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, 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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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, 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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, 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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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, 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

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 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<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_usize>

Which kind of iterator are we turning this into?

impl<T: Ord, U: Ord + ArraySize<T>> Ord for Array<T, U> where
    U::ArrayType: Ord, 

fn cmp(&self, other: &Array<T, U>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: PartialEq, U: PartialEq + ArraySize<T>> PartialEq<Array<T, U>> for Array<T, U> where
    U::ArrayType: 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: &Array<T, U>) -> bool

This method tests for !=.

impl<T: PartialOrd, U: PartialOrd + ArraySize<T>> PartialOrd<Array<T, U>> for Array<T, U> where
    U::ArrayType: 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 Array<T, U> where
    T: Copy,
    U: ArraySize<T>,
    U::ArrayType: TryFrom<&'a [T], Error = TryFromSliceError>, 

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<T: Copy, U: Copy + ArraySize<T>> Copy for Array<T, U> where
    U::ArrayType: Copy, 

impl<T: Eq, U: Eq + ArraySize<T>> Eq for Array<T, U> where
    U::ArrayType: Eq, 

impl<T, U: ArraySize<T>> StructuralEq for Array<T, U>

impl<T, U: ArraySize<T>> StructuralPartialEq for Array<T, U>