[−][src]Trait arraytools::ArrayTools
An extension trait for working with fixed-length arrays.
Use it with
use arraytools::ArrayTools;
For an overview, see the crate-level documentation.
(This trait is sealed; you are not allowed to implement it yourself.)
Associated Types
type Element
The type of the elements in this array
use arraytools::ArrayTools; [T; N]: ArrayTools<Element = T>
type Tuple
The homogeneous tuple type equivalent to this array type.
use arraytools::ArrayTools; [T; 4]: ArrayTools<Tuple = (T, T, T, T)>
Associated Constants
const LEN: usize
The number of the elements in this array
use arraytools::ArrayTools; assert_eq!(<[T; N] as ArrayTools>::LEN, N);
Required methods
fn as_slice(&self) -> &[Self::Element]
Extracts a slice containing the entire array.
use arraytools::ArrayTools; let array: [i32; 5] = [1, 2, 3, 4, 5]; let slice: &[i32] = array.as_slice(); assert_eq!(slice.len(), 5);
fn as_mut_slice(&mut self) -> &mut [Self::Element]
Extracts a mutable slice containing the entire array.
use arraytools::ArrayTools; let mut array: [i32; 5] = [1, 2, 3, 4, 5]; let slice: &mut [i32] = array.as_mut_slice(); assert_eq!(slice.len(), 5);
fn from_tuple(tuple: Self::Tuple) -> Self
Converts a homogeneous tuple into the equivalent array.
Type: (T, T, ..., T) -> [T; N]
use arraytools::ArrayTools; assert_eq!(<[_; 3]>::from_tuple((1, 2, 3)), [1, 2, 3]);
fn into_tuple(self) -> Self::Tuple
Converts this array into the equivalent homogeneous tuple.
Type: [T; N] -> (T, T, ..., T)
use arraytools::ArrayTools; assert_eq!([1, 2, 3].into_tuple(), (1, 2, 3));
Provided methods
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
Self: ArrayGenerate<F>,
Builds an array by calling the provided function.
Type: F -> [T; N]
- when
N <= 1
this requiresF: FnOnce() -> T
- when
N > 1
this requiresF: FnMut() -> T
use arraytools::ArrayTools; let mut x = 1; let array: [_; 5] = ArrayTools::generate(|| { x *= 2; x }); assert_eq!(array, [2, 4, 8, 16, 32]);
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
Self: ArrayRepeat<T>,
Builds an array by cloning the provided value.
Type: T -> [T; N]
use arraytools::ArrayTools; let mut v = Vec::with_capacity(10); v.push(42); let array: [_; 5] = ArrayTools::repeat(v); assert_eq!(array, [[42], [42], [42], [42], [42]]); assert_eq!(array[3].capacity(), 1); assert_eq!(array[4].capacity(), 10); // The last one is moved
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
Self: ArrayFromIter<I::IntoIter>,
Builds an array containing a prefix of the provided iterator,
or returns None
if it didn't contain sufficient items.
Type: impl IntoIterator<Item = T> -> Option<[T; N]>
use arraytools::ArrayTools; assert_eq!(<[i16; 4]>::from_iter(1..), Some([1, 2, 3, 4])); assert_eq!(<[_; 4]>::from_iter(1..4), None); assert_eq!(<[_; 4]>::from_iter(1..5), Some([1, 2, 3, 4])); assert_eq!(<[_; 4]>::from_iter(1..6), Some([1, 2, 3, 4])); assert_eq!(<[u8; 1]>::from_iter(Some(1)), Some([1])); assert_eq!(<[u8; 1]>::from_iter(None), None);
fn indices() -> Self where
Self: ArrayIndices,
Self: ArrayIndices,
Builds the array [0, 1, 2, ..., LEN-1]
.
Type: () -> [usize; N]
use arraytools::ArrayTools; let array: [_; 5] = ArrayTools::indices(); assert_eq!(array, [0, 1, 2, 3, 4]);
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
Self: ArrayMap<F>,
Builds a new array by applying the provided function to each element of this array.
Type: ([T; N], F) -> [U; N]
- when
N <= 1
this requiresF: FnOnce(T) -> U
- when
N > 1
this requiresF: FnMut(T) -> U
use arraytools::ArrayTools; assert_eq!([1, 10, 100].map(|x| x + 10), [11, 20, 110]);
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
Self: ArrayMap<F, OutputElement = ()>,
Runs the provided function on each element of this array.
Type: ([T; N], F) -> ()
- when
N <= 1
this requiresF: FnOnce(T) -> ()
- when
N > 1
this requiresF: FnMut(T) -> ()
use arraytools::ArrayTools; let mut array = [1, 10, 100]; array.as_mut_array().for_each(|x: &mut u8| *x += 10); assert_eq!(array, [11, 20, 110]);
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
Self: ArrayZip<T>,
Combines two equal-length arrays into an array of tuples.
Type: ([T; N], [U; N]) -> [(T, U); N]
use arraytools::ArrayTools; assert_eq!([10, 20, 30].zip([1.0, 2.0, 3.0]), [(10, 1.0), (20, 2.0), (30, 3.0)]);
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
Self: ArrayZipWith<T, F>,
Combines two equal-length arrays using the provided function.
Type: ([T; N], [U; N], F) -> [V; N]
- when
N <= 1
this requiresF: FnOnce(T, U) -> V
- when
N > 1
this requiresF: FnMut(T, U) -> V
use arraytools::ArrayTools; assert_eq!([10, 20, 30].zip_with([3, 2, 1], std::ops::Add::add), [13, 22, 31]);
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
Self: ArrayAsRef<'a>,
Builds an array of references to the elements of this array.
Type: &'a [T; N] -> [&'a T; N]
use arraytools::ArrayTools; let array = &[1, 2, 3, 4, 5]; assert_eq!(array.as_ref_array(), [&1, &2, &3, &4, &5]);
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
Self: ArrayAsMut<'a>,
Builds an array of mutable references to the elements of this array.
Type: &'a mut [T; N] -> [&'a mut T; N]
use arraytools::ArrayTools; let array = &mut [1, 2, 3]; assert_eq!(array.as_ref_array(), [&mut 1, &mut 2, &mut 3]);
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
Self: ArrayPush<U>,
Appends an item to this array, returning the new array
Type: ([T; N], T) -> [T; N+1]
use arraytools::ArrayTools; assert_eq!([1, 2].push_back(10), [1, 2, 10]);
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
Self: ArrayPush<U>,
Prepends an item to this array, returning the new array
Type: ([T; N], T) -> [T; N+1]
use arraytools::ArrayTools; assert_eq!([1, 2].push_front(10), [10, 1, 2]);
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
Self: ArrayPop<U>,
Splits the last item off from this array, returning a tuple of an array of the other elements and the split-off item.
Type: [T; N+1] -> ([T; N], T)
use arraytools::ArrayTools; assert_eq!([1, 2, 3].pop_back(), ([1, 2], 3));
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
Self: ArrayPop<U>,
Splits the first item off from this array, returning a tuple of an array of the other elements and the split-off item.
Type: [T; N+1] -> ([T; N], T)
use arraytools::ArrayTools; assert_eq!([1, 2, 3].pop_front(), ([2, 3], 1));
Implementors
impl<T> ArrayTools for [T; 0]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = ()
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 1]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T,)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 2]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 3]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 4]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 5]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 6]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 7]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 8]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 9]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 10]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 11]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 12]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 13]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 14]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 15]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 16]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 17]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 18]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 19]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 20]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 21]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 22]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 23]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 24]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 25]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 26]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 27]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 28]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 29]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 30]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 31]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
impl<T> ArrayTools for [T; 32]
[src]
type Element = T
const LEN: usize
[src]
fn as_slice(&self) -> &[Self::Element]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Element]
[src]
type Tuple = (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
fn from_tuple(tuple: Self::Tuple) -> Self
[src]
fn into_tuple(self) -> Self::Tuple
[src]
fn generate<F>(f: F) -> Self where
Self: ArrayGenerate<F>,
[src]
Self: ArrayGenerate<F>,
fn repeat<T: Clone>(x: T) -> Self where
Self: ArrayRepeat<T>,
[src]
Self: ArrayRepeat<T>,
fn from_iter<I: IntoIterator>(it: I) -> Option<Self> where
Self: ArrayFromIter<I::IntoIter>,
[src]
Self: ArrayFromIter<I::IntoIter>,
fn indices() -> Self where
Self: ArrayIndices,
[src]
Self: ArrayIndices,
#[must_use = "if you don\'t need the result, use `for_each`"]
fn map<F>(self, f: F) -> Self::Output where
Self: ArrayMap<F>,
[src]
Self: ArrayMap<F>,
fn for_each<F>(self, f: F) where
Self: ArrayMap<F, OutputElement = ()>,
[src]
Self: ArrayMap<F, OutputElement = ()>,
fn zip<T>(self, other: T) -> Self::Output where
Self: ArrayZip<T>,
[src]
Self: ArrayZip<T>,
fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where
Self: ArrayZipWith<T, F>,
[src]
Self: ArrayZipWith<T, F>,
fn as_ref_array<'a>(&'a self) -> Self::Output where
Self: ArrayAsRef<'a>,
[src]
Self: ArrayAsRef<'a>,
fn as_mut_array<'a>(&'a mut self) -> Self::Output where
Self: ArrayAsMut<'a>,
[src]
Self: ArrayAsMut<'a>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_back<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn push_front<U>(self, item: U) -> Self::Output where
Self: ArrayPush<U>,
[src]
Self: ArrayPush<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_back<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,
#[must_use = "this returns the new array; it doesn\'t update the existing one"]
fn pop_front<U>(self) -> (Self::Output, U) where
Self: ArrayPop<U>,
[src]
Self: ArrayPop<U>,