[−][src]Trait arraylib::Array
Represent array of some size. E.g.: [u8; 32]
, [&str; 8]
, [T; N]
.
Sizes
See Sizes Limitations paragraph in crate docs.
Safety
By implementing this trait for type T
you guarantee that
T
has the same ABI as[T::Item; T::Size]
T::Maybe
is an array of the same type ([MeybeUninit<T::Item>; T::Size]
)
Violating these rules will cause UB.
It is highly not recommended to implement this trait on your type unless you really know what you are doing.
Associated Types
type Item
Type of the Items in the array. i.e.
[T; 4]: Array<Item = T>
type Maybe: Array<Item = MaybeUninit<Self::Item>>
Same array but item is wrapped with
MaybeUninit<_>
.
[T; 4]: Array<Item = T, Maybe = [core::mem::MaybeUninit<T>; 4]>
Associated Constants
const SIZE: usize
Size of the array.
Example
use arraylib::Array; assert_eq!(<[(); 0]>::SIZE, 0); assert_eq!(<[(); 2]>::SIZE, 2);
Required methods
fn as_slice(&self) -> &[Self::Item]
Extracts a slice containing the entire array.
Example
use arraylib::Array; let array = [1, 2, 3]; assert_eq!(array.as_slice()[1..], [2, 3]);
fn as_mut_slice(&mut self) -> &mut [Self::Item]
Extracts a mutable slice of the entire array.
Example
use arraylib::Array; let mut array = [1, 0, 1]; array.as_mut_slice()[1] = 2; assert_eq!(array, [1, 2, 1]);
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
F: FnMut(&mut St) -> Result<Self::Item, E>,
Create new array, filled with elements returned by f
. If f
return
Err
then this method also return Err
.
Example
use arraylib::Array; let f = |it: &mut u32| { let res = Ok(*it); *it = it.checked_sub(10).ok_or(())?; res }; let arr = <[_; 3]>::try_unfold(30, f); assert_eq!(arr, Ok([30, 20, 10])); let arr = <[_; 10]>::try_unfold(40, f); assert_eq!(arr, Err(()));
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
F: FnMut(&mut St) -> Self::Item,
Create new array, filled with elements returned by f
Example
use arraylib::Array; let arr = <[_; 11]>::unfold(1, |it| { let res = *it; *it *= -2; res }); assert_eq!(arr, [1, -2, 4, -8, 16, -32, 64, -128, 256, -512, 1024]);
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
F: FnMut(usize) -> Result<Self::Item, E>,
Create new array, filled with elements returned by f
. If f
return
Err
then this method also return Err
.
Example
use arraylib::Array; let f = |it| 250u8.checked_add(it as u8).ok_or(()); let arr = <[_; 3]>::try_from_fn(f); assert_eq!(arr, Ok([250, 251, 252])); let arr = <[_; 10]>::try_from_fn(f); assert_eq!(arr, Err(()));
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
F: FnMut(usize) -> Self::Item,
Create new array, filled with elements returned by f
Example
use arraylib::Array; let arr = <[_; 11]>::from_fn(|it| it.pow(2)); assert_eq!(arr, [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]);
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
I: IntoIterator<Item = Self::Item>,
Creates an array from an iterator.
Examples
use arraylib::{Array, ArrayExt}; let iter = [-2, -1, 0, 1, 2].iter_move().filter(|it| it % 2 == 0); let arr = <[i32; 2]>::from_iter(iter); assert_eq!(arr, Some([-2, 0])); // ^^^^^---- Note: `2` wasn't consumed
use arraylib::Array; use std::iter::once; let arr = <[i32; 2]>::from_iter(once(0)); assert_eq!(arr, None);
Provided methods
fn into_uninit(self) -> Self::Maybe
Converts self into [MaybeUninit<Self::Item>; Self::Size]
. This
function is used internally in this crate for some unsafe code.
Example
use arraylib::Array; use std::mem::MaybeUninit; let _: [MaybeUninit<bool>; 3] = [true, false, false].into_uninit();
fn uninit() -> Self::Maybe
Creates uninitialized array of MaybeUninit<T>
.
Example
use arraylib::Array; use std::mem::MaybeUninit; let _: [MaybeUninit<i32>; 3] = <[i32; 3]>::uninit();
unsafe fn assume_init(uninit: Self::Maybe) -> Self
Extracts the values from the MaybeUninit<T>
containers.
Safety
It is up to the caller to guarantee that all elements of the array are
really in an initialized state. Calling this when the content is not
yet fully initialized causes immediate undefined behavior. The
MaybeUninit's
type-level documentation contains
more information about this initialization invariant.
See also MaybeUninit::assume_init
documentation.
Examples
Correct usage of this method:
use arraylib::Array; use std::mem::MaybeUninit; let mut arr: [MaybeUninit<bool>; 4] = <[bool; 4]>::uninit(); for x in arr.iter_mut() { unsafe { x.as_mut_ptr().write(true) }; } let arr_init: [bool; 4] = unsafe { <_>::assume_init(arr) }; assert_eq!(arr_init, [true; 4]);
Incorrect usage of this method:
use arraylib::Array; use std::mem::MaybeUninit; let mut arr: [MaybeUninit<bool>; 4] = <[bool; 4]>::uninit(); for i in 0..3 { unsafe { arr[i].as_mut_ptr().write(true) }; } let arr_init: [bool; 4] = unsafe { <_>::assume_init(arr) }; // `arr[3]` had not been initialized yet, so this last line caused undefined behavior.
fn into_boxed_slice(self) -> Box<[Self::Item]>
Converts self
into Box<[Self::Item]>
Implementors
impl<A> Array for ArrayWrapper<A> where
A: Array,
[src]
A: Array,
Safety
ArrayWrapper
has #[repr(transparent)]
so it has the same ABI as A
.
So if A
is array then so is ArrayWrapper
.
type Item = A::Item
type Maybe = ArrayWrapper<A::Maybe>
const SIZE: usize
[src]
fn as_slice(&self) -> &[Self::Item]
[src]
fn as_mut_slice(&mut self) -> &mut [Self::Item]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_uninit(self) -> Self::Maybe
[src]
impl<T> Array for [T; 0]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 0]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(_init: St, _f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(_init: St, _f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(_f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(_f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(_iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_uninit(self) -> Self::Maybe
[src]
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 1]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 1]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 2]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 2]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 3]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 3]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 4]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 4]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 5]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 5]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 6]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 6]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 7]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 7]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 8]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 8]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 9]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 9]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 10]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 10]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 11]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 11]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 12]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 12]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 13]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 13]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 14]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 14]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 15]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 15]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 16]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 16]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 17]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 17]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 18]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 18]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 19]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 19]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 20]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 20]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 21]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 21]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 22]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 22]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 23]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 23]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 24]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 24]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 25]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 25]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 26]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 26]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 27]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 27]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 28]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 28]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 29]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 29]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 30]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 30]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 31]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 31]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 32]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 32]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 33]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 33]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 34]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 34]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 35]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 35]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 36]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 36]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 37]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 37]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 38]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 38]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 39]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 39]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 40]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 40]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 41]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 41]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 42]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 42]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 43]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 43]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 44]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 44]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 45]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 45]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 46]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 46]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 47]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 47]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 48]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 48]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 49]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 49]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 50]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 50]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 51]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 51]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 52]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 52]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 53]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 53]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 54]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 54]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 55]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 55]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 56]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 56]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 57]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 57]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 58]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 58]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 59]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 59]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 60]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 60]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 61]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 61]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 62]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 62]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 63]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 63]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 64]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 64]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 65]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 65]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 66]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 66]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 67]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 67]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 68]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 68]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 69]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 69]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 70]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 70]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 71]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 71]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 72]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 72]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 73]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 73]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 74]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 74]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 75]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 75]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 76]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 76]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 77]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 77]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 78]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 78]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 79]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 79]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 80]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 80]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 81]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 81]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 82]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 82]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 83]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 83]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 84]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 84]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 85]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 85]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 86]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 86]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 87]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 87]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 88]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 88]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 89]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 89]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 90]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 90]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 91]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 91]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 92]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 92]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 93]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 93]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 94]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 94]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 95]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 95]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 96]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 96]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 97]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 97]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 98]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 98]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 99]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 99]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 100]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 100]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 101]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 101]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 102]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 102]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 103]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 103]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 104]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 104]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 105]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 105]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 106]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 106]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 107]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 107]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 108]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 108]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 109]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 109]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 110]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 110]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 111]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 111]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 112]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 112]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 113]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 113]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 114]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 114]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 115]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 115]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 116]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 116]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 117]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 117]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 118]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 118]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 119]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 119]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 120]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 120]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 121]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 121]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 122]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 122]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 123]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 123]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 124]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 124]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 125]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 125]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 126]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 126]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 127]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 127]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 128]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 128]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 200]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 200]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 256]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 256]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 300]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 300]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 400]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 400]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 500]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 500]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 512]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 512]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 600]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 600]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 700]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 700]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 800]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 800]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 900]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 900]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 1000]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 1000]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 1024]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 1024]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 2048]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 2048]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 4096]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 4096]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 8192]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 8192]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 16384]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 16384]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 32768]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 32768]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,
fn into_boxed_slice(self) -> Box<[Self::Item]>
[src]
impl<T> Array for [T; 65536]
[src]
type Item = T
type Maybe = [MaybeUninit<T>; 65536]
const SIZE: usize
[src]
fn as_slice(&self) -> &[T]
[src]
fn as_mut_slice(&mut self) -> &mut [T]
[src]
fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
F: FnMut(&mut St) -> Result<Self::Item, E>,
[src]
F: FnMut(&mut St) -> Result<Self::Item, E>,
fn unfold<St, F>(init: St, f: F) -> Self where
F: FnMut(&mut St) -> Self::Item,
[src]
F: FnMut(&mut St) -> Self::Item,
fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
F: FnMut(usize) -> Result<Self::Item, E>,
[src]
F: FnMut(usize) -> Result<Self::Item, E>,
fn from_fn<F>(f: F) -> Self where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn from_iter<I>(iter: I) -> Option<Self> where
I: IntoIterator<Item = Self::Item>,
[src]
I: IntoIterator<Item = Self::Item>,