Trait arraylib::Array

pub unsafe trait Array: Sized {
    type Item;
    type Maybe: Array<Item = MaybeUninit<Self::Item>>;

    const SIZE: usize;

    fn as_slice(&self) -> &[Self::Item];
    fn as_mut_slice(&mut self) -> &mut [Self::Item];
    fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E>
    where
        F: FnMut(&mut St) -> Result<Self::Item, E>;
    fn unfold<St, F>(init: St, f: F) -> Self
    where
        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>;
    fn from_fn<F>(f: F) -> Self
    where
        F: FnMut(usize) -> Self::Item;
    fn from_iter<I>(iter: I) -> Option<Self>
    where
        I: IntoIterator<Item = Self::Item>;

    fn into_uninit(self) -> Self::Maybe { ... }
    fn uninit() -> Self::Maybe { ... }
    unsafe fn assume_init(uninit: Self::Maybe) -> Self { ... }
    fn into_boxed_slice(self) -> Box<[Self::Item]> { ... }
}

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

1. T has the same ABI as [T::Item; T::Size]
2. 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]>

Loading content...

Associated Constants

const SIZE: usize

Size of the array.

Example

use arraylib::Array;

assert_eq!(<[(); 0]>::SIZE, 0);
assert_eq!(<[(); 2]>::SIZE, 2);

Loading content...

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

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, 

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

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, 

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

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);

Loading content...

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

Loading content...

Implementors

impl<A> Array for ArrayWrapper<A> where
    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

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_uninit(self) -> Self::Maybe

impl<T> Array for [T; 0]

type Item = T

type Maybe = [MaybeUninit<T>; 0]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(_init: St, _f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(_init: St, _f: F) -> Self where
    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>, 

fn from_fn<F>(_f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(_iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_uninit(self) -> Self::Maybe

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 1]

type Item = T

type Maybe = [MaybeUninit<T>; 1]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 2]

type Item = T

type Maybe = [MaybeUninit<T>; 2]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 3]

type Item = T

type Maybe = [MaybeUninit<T>; 3]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 4]

type Item = T

type Maybe = [MaybeUninit<T>; 4]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 5]

type Item = T

type Maybe = [MaybeUninit<T>; 5]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 6]

type Item = T

type Maybe = [MaybeUninit<T>; 6]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 7]

type Item = T

type Maybe = [MaybeUninit<T>; 7]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 8]

type Item = T

type Maybe = [MaybeUninit<T>; 8]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 9]

type Item = T

type Maybe = [MaybeUninit<T>; 9]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 10]

type Item = T

type Maybe = [MaybeUninit<T>; 10]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 11]

type Item = T

type Maybe = [MaybeUninit<T>; 11]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 12]

type Item = T

type Maybe = [MaybeUninit<T>; 12]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 13]

type Item = T

type Maybe = [MaybeUninit<T>; 13]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 14]

type Item = T

type Maybe = [MaybeUninit<T>; 14]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 15]

type Item = T

type Maybe = [MaybeUninit<T>; 15]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 16]

type Item = T

type Maybe = [MaybeUninit<T>; 16]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 17]

type Item = T

type Maybe = [MaybeUninit<T>; 17]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 18]

type Item = T

type Maybe = [MaybeUninit<T>; 18]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 19]

type Item = T

type Maybe = [MaybeUninit<T>; 19]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 20]

type Item = T

type Maybe = [MaybeUninit<T>; 20]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 21]

type Item = T

type Maybe = [MaybeUninit<T>; 21]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 22]

type Item = T

type Maybe = [MaybeUninit<T>; 22]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 23]

type Item = T

type Maybe = [MaybeUninit<T>; 23]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 24]

type Item = T

type Maybe = [MaybeUninit<T>; 24]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 25]

type Item = T

type Maybe = [MaybeUninit<T>; 25]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 26]

type Item = T

type Maybe = [MaybeUninit<T>; 26]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 27]

type Item = T

type Maybe = [MaybeUninit<T>; 27]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 28]

type Item = T

type Maybe = [MaybeUninit<T>; 28]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 29]

type Item = T

type Maybe = [MaybeUninit<T>; 29]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 30]

type Item = T

type Maybe = [MaybeUninit<T>; 30]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 31]

type Item = T

type Maybe = [MaybeUninit<T>; 31]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 32]

type Item = T

type Maybe = [MaybeUninit<T>; 32]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 33]

type Item = T

type Maybe = [MaybeUninit<T>; 33]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 34]

type Item = T

type Maybe = [MaybeUninit<T>; 34]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 35]

type Item = T

type Maybe = [MaybeUninit<T>; 35]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 36]

type Item = T

type Maybe = [MaybeUninit<T>; 36]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 37]

type Item = T

type Maybe = [MaybeUninit<T>; 37]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 38]

type Item = T

type Maybe = [MaybeUninit<T>; 38]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 39]

type Item = T

type Maybe = [MaybeUninit<T>; 39]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 40]

type Item = T

type Maybe = [MaybeUninit<T>; 40]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 41]

type Item = T

type Maybe = [MaybeUninit<T>; 41]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 42]

type Item = T

type Maybe = [MaybeUninit<T>; 42]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 43]

type Item = T

type Maybe = [MaybeUninit<T>; 43]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 44]

type Item = T

type Maybe = [MaybeUninit<T>; 44]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 45]

type Item = T

type Maybe = [MaybeUninit<T>; 45]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 46]

type Item = T

type Maybe = [MaybeUninit<T>; 46]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 47]

type Item = T

type Maybe = [MaybeUninit<T>; 47]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 48]

type Item = T

type Maybe = [MaybeUninit<T>; 48]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 49]

type Item = T

type Maybe = [MaybeUninit<T>; 49]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 50]

type Item = T

type Maybe = [MaybeUninit<T>; 50]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 51]

type Item = T

type Maybe = [MaybeUninit<T>; 51]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 52]

type Item = T

type Maybe = [MaybeUninit<T>; 52]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 53]

type Item = T

type Maybe = [MaybeUninit<T>; 53]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 54]

type Item = T

type Maybe = [MaybeUninit<T>; 54]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 55]

type Item = T

type Maybe = [MaybeUninit<T>; 55]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 56]

type Item = T

type Maybe = [MaybeUninit<T>; 56]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 57]

type Item = T

type Maybe = [MaybeUninit<T>; 57]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 58]

type Item = T

type Maybe = [MaybeUninit<T>; 58]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 59]

type Item = T

type Maybe = [MaybeUninit<T>; 59]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 60]

type Item = T

type Maybe = [MaybeUninit<T>; 60]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 61]

type Item = T

type Maybe = [MaybeUninit<T>; 61]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 62]

type Item = T

type Maybe = [MaybeUninit<T>; 62]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 63]

type Item = T

type Maybe = [MaybeUninit<T>; 63]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 64]

type Item = T

type Maybe = [MaybeUninit<T>; 64]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 65]

type Item = T

type Maybe = [MaybeUninit<T>; 65]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 66]

type Item = T

type Maybe = [MaybeUninit<T>; 66]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 67]

type Item = T

type Maybe = [MaybeUninit<T>; 67]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 68]

type Item = T

type Maybe = [MaybeUninit<T>; 68]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 69]

type Item = T

type Maybe = [MaybeUninit<T>; 69]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 70]

type Item = T

type Maybe = [MaybeUninit<T>; 70]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 71]

type Item = T

type Maybe = [MaybeUninit<T>; 71]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 72]

type Item = T

type Maybe = [MaybeUninit<T>; 72]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 73]

type Item = T

type Maybe = [MaybeUninit<T>; 73]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 74]

type Item = T

type Maybe = [MaybeUninit<T>; 74]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 75]

type Item = T

type Maybe = [MaybeUninit<T>; 75]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 76]

type Item = T

type Maybe = [MaybeUninit<T>; 76]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 77]

type Item = T

type Maybe = [MaybeUninit<T>; 77]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 78]

type Item = T

type Maybe = [MaybeUninit<T>; 78]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 79]

type Item = T

type Maybe = [MaybeUninit<T>; 79]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 80]

type Item = T

type Maybe = [MaybeUninit<T>; 80]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 81]

type Item = T

type Maybe = [MaybeUninit<T>; 81]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 82]

type Item = T

type Maybe = [MaybeUninit<T>; 82]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 83]

type Item = T

type Maybe = [MaybeUninit<T>; 83]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 84]

type Item = T

type Maybe = [MaybeUninit<T>; 84]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 85]

type Item = T

type Maybe = [MaybeUninit<T>; 85]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 86]

type Item = T

type Maybe = [MaybeUninit<T>; 86]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 87]

type Item = T

type Maybe = [MaybeUninit<T>; 87]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 88]

type Item = T

type Maybe = [MaybeUninit<T>; 88]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 89]

type Item = T

type Maybe = [MaybeUninit<T>; 89]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 90]

type Item = T

type Maybe = [MaybeUninit<T>; 90]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 91]

type Item = T

type Maybe = [MaybeUninit<T>; 91]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 92]

type Item = T

type Maybe = [MaybeUninit<T>; 92]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 93]

type Item = T

type Maybe = [MaybeUninit<T>; 93]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 94]

type Item = T

type Maybe = [MaybeUninit<T>; 94]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 95]

type Item = T

type Maybe = [MaybeUninit<T>; 95]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 96]

type Item = T

type Maybe = [MaybeUninit<T>; 96]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 97]

type Item = T

type Maybe = [MaybeUninit<T>; 97]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 98]

type Item = T

type Maybe = [MaybeUninit<T>; 98]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 99]

type Item = T

type Maybe = [MaybeUninit<T>; 99]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 100]

type Item = T

type Maybe = [MaybeUninit<T>; 100]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 101]

type Item = T

type Maybe = [MaybeUninit<T>; 101]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 102]

type Item = T

type Maybe = [MaybeUninit<T>; 102]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 103]

type Item = T

type Maybe = [MaybeUninit<T>; 103]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 104]

type Item = T

type Maybe = [MaybeUninit<T>; 104]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 105]

type Item = T

type Maybe = [MaybeUninit<T>; 105]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 106]

type Item = T

type Maybe = [MaybeUninit<T>; 106]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 107]

type Item = T

type Maybe = [MaybeUninit<T>; 107]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 108]

type Item = T

type Maybe = [MaybeUninit<T>; 108]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 109]

type Item = T

type Maybe = [MaybeUninit<T>; 109]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 110]

type Item = T

type Maybe = [MaybeUninit<T>; 110]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 111]

type Item = T

type Maybe = [MaybeUninit<T>; 111]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 112]

type Item = T

type Maybe = [MaybeUninit<T>; 112]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 113]

type Item = T

type Maybe = [MaybeUninit<T>; 113]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 114]

type Item = T

type Maybe = [MaybeUninit<T>; 114]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 115]

type Item = T

type Maybe = [MaybeUninit<T>; 115]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 116]

type Item = T

type Maybe = [MaybeUninit<T>; 116]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 117]

type Item = T

type Maybe = [MaybeUninit<T>; 117]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 118]

type Item = T

type Maybe = [MaybeUninit<T>; 118]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 119]

type Item = T

type Maybe = [MaybeUninit<T>; 119]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 120]

type Item = T

type Maybe = [MaybeUninit<T>; 120]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 121]

type Item = T

type Maybe = [MaybeUninit<T>; 121]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 122]

type Item = T

type Maybe = [MaybeUninit<T>; 122]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 123]

type Item = T

type Maybe = [MaybeUninit<T>; 123]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 124]

type Item = T

type Maybe = [MaybeUninit<T>; 124]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 125]

type Item = T

type Maybe = [MaybeUninit<T>; 125]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 126]

type Item = T

type Maybe = [MaybeUninit<T>; 126]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 127]

type Item = T

type Maybe = [MaybeUninit<T>; 127]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 128]

type Item = T

type Maybe = [MaybeUninit<T>; 128]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 200]

type Item = T

type Maybe = [MaybeUninit<T>; 200]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 256]

type Item = T

type Maybe = [MaybeUninit<T>; 256]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 300]

type Item = T

type Maybe = [MaybeUninit<T>; 300]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 400]

type Item = T

type Maybe = [MaybeUninit<T>; 400]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 500]

type Item = T

type Maybe = [MaybeUninit<T>; 500]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 512]

type Item = T

type Maybe = [MaybeUninit<T>; 512]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 600]

type Item = T

type Maybe = [MaybeUninit<T>; 600]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 700]

type Item = T

type Maybe = [MaybeUninit<T>; 700]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 800]

type Item = T

type Maybe = [MaybeUninit<T>; 800]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 900]

type Item = T

type Maybe = [MaybeUninit<T>; 900]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 1000]

type Item = T

type Maybe = [MaybeUninit<T>; 1000]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 1024]

type Item = T

type Maybe = [MaybeUninit<T>; 1024]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 2048]

type Item = T

type Maybe = [MaybeUninit<T>; 2048]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 4096]

type Item = T

type Maybe = [MaybeUninit<T>; 4096]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 8192]

type Item = T

type Maybe = [MaybeUninit<T>; 8192]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 16384]

type Item = T

type Maybe = [MaybeUninit<T>; 16384]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 32768]

type Item = T

type Maybe = [MaybeUninit<T>; 32768]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

impl<T> Array for [T; 65536]

type Item = T

type Maybe = [MaybeUninit<T>; 65536]

const SIZE: usize

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

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

fn try_unfold<St, F, E>(init: St, f: F) -> Result<Self, E> where
    F: FnMut(&mut St) -> Result<Self::Item, E>, 

fn unfold<St, F>(init: St, f: F) -> Self where
    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>, 

fn from_fn<F>(f: F) -> Self where
    F: FnMut(usize) -> Self::Item, 

fn from_iter<I>(iter: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

fn into_boxed_slice(self) -> Box<[Self::Item]>

Loading content...