[−][src]Trait arraytools::ArrayTools

pub trait ArrayTools: Sized + Sealed {
    type Element;
    type Tuple;

    const LEN: usize;

    fn as_slice(&self) -> &[Self::Element];
    fn as_mut_slice(&mut self) -> &mut [Self::Element];
    fn from_tuple(tuple: Self::Tuple) -> Self;
    fn into_tuple(self) -> Self::Tuple;

    fn generate<F>(f: F) -> Self
    where
        Self: ArrayGenerate<F>,
    { ... }
    fn repeat<T: Clone>(x: T) -> Self
    where
        Self: ArrayRepeat<T>,
    { ... }
    fn indices() -> Self
    where
        Self: ArrayIndices,
    { ... }
    fn map<T, F>(self, f: F) -> Self::Output
    where
        Self: ArrayMap<T, F>,
    { ... }
    fn zip<T>(self, other: T) -> Self::Output
    where
        Self: ArrayZip<T>,
    { ... }
    fn zip_with<T, F>(self, other: T, f: F) -> Self::Output
    where
        Self: ArrayZipWith<T, F>,
    { ... }
    fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output
    where
        &'a Self: ArrayAsRef,
    { ... }
    fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output
    where
        &'a mut Self: ArrayAsMut,
    { ... }
    fn push_back<U>(self, item: U) -> Self::Output
    where
        Self: ArrayPush<U>,
    { ... }
    fn push_front<U>(self, item: U) -> Self::Output
    where
        Self: ArrayPush<U>,
    { ... }
    fn pop_back<U>(self) -> (Self::Output, U)
    where
        Self: ArrayPop<U>,
    { ... }
    fn pop_front<U>(self) -> (Self::Output, U)
    where
        Self: ArrayPop<U>,
    { ... }
}

Associated Types

`type Element`

`type Tuple`

Loading content...

Associated Constants

`const LEN: usize`

Loading content...

Required methods

`fn as_slice(&self) -> &[Self::Element]`

`fn as_mut_slice(&mut self) -> &mut [Self::Element]`

`fn from_tuple(tuple: Self::Tuple) -> Self`

`fn into_tuple(self) -> Self::Tuple`

Loading content...

Provided methods

`fn generate<F>(f: F) -> Self where Self: ArrayGenerate<F>,`

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,`

`fn indices() -> Self where Self: ArrayIndices,`

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,`

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,`

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,`

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,`

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,`

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,`

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,`

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,`

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,`

Loading content...

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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn push_front(self, item: U) -> Self::Output where Self: ArrayPush,` [src]

`fn pop_back(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

`fn pop_front(self) -> (Self::Output, U) where Self: ArrayPop,` [src]

Loading content...

[−][src]Trait arraytools::ArrayTools

Associated Types

type Element

type Tuple

Associated Constants

const LEN: usize

Required methods

fn as_slice(&self) -> &[Self::Element]

fn as_mut_slice(&mut self) -> &mut [Self::Element]

fn from_tuple(tuple: Self::Tuple) -> Self

fn into_tuple(self) -> Self::Tuple

Provided methods

fn generate<F>(f: F) -> Self where Self: ArrayGenerate<F>,

fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,

fn indices() -> Self where Self: ArrayIndices,

fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,

fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,

fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,

fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,

fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,

fn push_back<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,

fn push_front<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,

fn pop_back<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,

fn pop_front<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,

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]

fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>, [src]

fn indices() -> Self where Self: ArrayIndices, [src]

fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>, [src]

fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>, [src]

fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>, [src]

fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef, [src]

fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut, [src]

fn push_back<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>, [src]

fn push_front<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>, [src]

fn pop_back<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>, [src]

fn pop_front<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>, [src]

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]

fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>, [src]

fn indices() -> Self where Self: ArrayIndices, [src]

fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>, [src]

fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>, [src]

fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>, [src]

fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef, [src]

fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut, [src]

fn push_back<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>, [src]

fn push_front<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>, [src]

fn pop_back<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>, [src]

fn pop_front<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>, [src]

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]

fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>, [src]

fn indices() -> Self where Self: ArrayIndices, [src]

fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>, [src]

fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>, [src]

fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>, [src]

fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef, [src]

`type Element`

`type Tuple`

`const LEN: usize`

`fn as_slice(&self) -> &[Self::Element]`

`fn as_mut_slice(&mut self) -> &mut [Self::Element]`

`fn from_tuple(tuple: Self::Tuple) -> Self`

`fn into_tuple(self) -> Self::Tuple`

`fn generate<F>(f: F) -> Self where Self: ArrayGenerate<F>,`

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,`

`fn indices() -> Self where Self: ArrayIndices,`

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,`

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,`

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,`

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,`

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,`

`fn push_back<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,`

`fn push_front<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,`

`fn pop_back<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,`

`fn pop_front<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,`

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,` [src]

`fn push_front<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,` [src]

`fn pop_back<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,` [src]

`fn pop_front<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,` [src]

`fn push_front<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,` [src]

`fn pop_back<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,` [src]

`fn pop_front<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,` [src]

`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]

`fn repeat<T: Clone>(x: T) -> Self where Self: ArrayRepeat<T>,` [src]

`fn indices() -> Self where Self: ArrayIndices,` [src]

`fn map<T, F>(self, f: F) -> Self::Output where Self: ArrayMap<T, F>,` [src]

`fn zip<T>(self, other: T) -> Self::Output where Self: ArrayZip<T>,` [src]

`fn zip_with<T, F>(self, other: T, f: F) -> Self::Output where Self: ArrayZipWith<T, F>,` [src]

`fn as_ref_array<'a>(&'a self) -> <&'a Self as ArrayAsRef>::Output where &'a Self: ArrayAsRef,` [src]

`fn as_mut_array<'a>(&'a mut self) -> <&'a mut Self as ArrayAsMut>::Output where &'a mut Self: ArrayAsMut,` [src]

`fn push_back<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,` [src]

`fn push_front<U>(self, item: U) -> Self::Output where Self: ArrayPush<U>,` [src]

`fn pop_back<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,` [src]

`fn pop_front<U>(self) -> (Self::Output, U) where Self: ArrayPop<U>,` [src]

`impl<T> ArrayTools for [T; 3]`[src]