Type Alias holochain::prelude::CapSecretBytes

pub type CapSecretBytes = [u8; 64];

A fixed size array of bytes that a secret must be.

Implementations

impl<const N: usize> [u8; N]

pub const fn as_ascii(&self) -> Option<&[AsciiChar; N]>

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters, or returns None if any of the characters is non-ASCII.

Examples

#![feature(ascii_char)]
#![feature(const_option)]

const HEX_DIGITS: [std::ascii::Char; 16] =
    *b"0123456789abcdef".as_ascii().unwrap();

assert_eq!(HEX_DIGITS[1].as_str(), "1");
assert_eq!(HEX_DIGITS[10].as_str(), "a");

pub const unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters, without checking whether they’re valid.

Safety

Every byte in the array must be in 0..=127, or else this is UB.

impl<T, const N: usize> [T; N]

pub fn map<F, U>(self, f: F) -> [U; N]where F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element in order.

If you don’t necessarily need a new fixed-size array, consider using Iterator::map instead.

Note on performance and stack usage

Unfortunately, usages of this method are currently not always optimized as well as they could be. This mainly concerns large arrays, as mapping over small arrays seem to be optimized just fine. Also note that in debug mode (i.e. without any optimizations), this method can use a lot of stack space (a few times the size of the array or more).

Therefore, in performance-critical code, try to avoid using this method on large arrays or check the emitted code. Also try to avoid chained maps (e.g. arr.map(...).map(...)).

In many cases, you can instead use Iterator::map by calling .iter() or .into_iter() on your array. [T; N]::map is only necessary if you really need a new array of the same size as the result. Rust’s lazy iterators tend to get optimized very well.

Examples

let x = [1, 2, 3];
let y = x.map(|v| v + 1);
assert_eq!(y, [2, 3, 4]);

let x = [1, 2, 3];
let mut temp = 0;
let y = x.map(|v| { temp += 1; v * temp });
assert_eq!(y, [1, 4, 9]);

let x = ["Ferris", "Bueller's", "Day", "Off"];
let y = x.map(|v| v.len());
assert_eq!(y, [6, 9, 3, 3]);

pub fn try_map<F, R>( self, f: F ) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryTypewhere F: FnMut(T) -> R, R: Try, <R as Try>::Residual: Residual<[<R as Try>::Output; N]>,

🔬This is a nightly-only experimental API. (array_try_map)

A fallible function f applied to each element on array self in order to return an array the same size as self or the first error encountered.

The return type of this function depends on the return type of the closure. If you return Result<T, E> from the closure, you’ll get a Result<[T; N], E>. If you return Option<T> from the closure, you’ll get an Option<[T; N]>.

Examples

#![feature(array_try_map)]
let a = ["1", "2", "3"];
let b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);
assert_eq!(b, [2, 3, 4]);

let a = ["1", "2a", "3"];
let b = a.try_map(|v| v.parse::<u32>());
assert!(b.is_err());

use std::num::NonZeroU32;
let z = [1, 2, 0, 3, 4];
assert_eq!(z.try_map(NonZeroU32::new), None);
let a = [1, 2, 3];
let b = a.try_map(NonZeroU32::new);
let c = b.map(|x| x.map(NonZeroU32::get));
assert_eq!(c, Some(a));

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

Returns a slice containing the entire array. Equivalent to &s[..].

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

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

pub fn each_ref(&self) -> [&T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same size as self.

Example

#![feature(array_methods)]

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

#![feature(array_methods)]

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

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

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element mutably and returns an array of mutable references with the same size as self.

Example

#![feature(array_methods)]

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, &mut [3, 0, 5, 6][..]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

Trait Implementations

impl<const N: usize, I, O, E, P> Alt<I, O, E> for [P; N]where I: Stream, E: ParserError<I>, P: Parser<I, O, E>,

fn choice(&mut self, input: &mut I) -> Result<O, ErrMode<E>>

Tests each parser in the tuple and returns the result of the first one that succeeds

impl<'a, T, const N: usize> Arbitrary<'a> for [T; N]where T: Arbitrary<'a>,

fn arbitrary(u: &mut Unstructured<'a>) -> Result<[T; N], Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<[T; N], Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(d: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<T, const N: usize> Archive for [T; N]where T: Archive,

type Archived = [<T as Archive>::Archived; N]

The archived representation of this type.

type Resolver = [<T as Archive>::Resolver; N]

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <[T; N] as Archive>::Resolver, out: *mut <[T; N] as Archive>::Archived )

Creates the archived version of this value at the given position and writes it to the given output.

impl<T> Array for [T; 0]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 0]

type Item = T

The array’s element type

const CAPACITY: usize = 0usize

The array’s element capacity

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

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

impl<T> Array for [T; 0]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 0usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 0]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 1]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 1]

type Item = T

The array’s element type

const CAPACITY: usize = 1usize

The array’s element capacity

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

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

impl<T> Array for [T; 1]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 1usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 1]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 10]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 10]

type Item = T

The array’s element type

const CAPACITY: usize = 10usize

The array’s element capacity

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

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

impl<T> Array for [T; 10]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 10usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 10]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 100]

type Item = T

The array’s element type

const CAPACITY: usize = 100usize

The array’s element capacity

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

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

impl<T> Array for [T; 1024]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 1024]

type Item = T

The array’s element type

const CAPACITY: usize = 1_024usize

The array’s element capacity

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

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

impl<T> Array for [T; 1024]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 1_024usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 1024]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 1048576]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 11]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 11]

type Item = T

The array’s element type

const CAPACITY: usize = 11usize

The array’s element capacity

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

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

impl<T> Array for [T; 11]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 11usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 11]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 12]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 12]

type Item = T

The array’s element type

const CAPACITY: usize = 12usize

The array’s element capacity

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

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

impl<T> Array for [T; 12]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 12usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 12]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 128]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 128]

type Item = T

The array’s element type

const CAPACITY: usize = 128usize

The array’s element capacity

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

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

impl<T> Array for [T; 128]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 128usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 128]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 13]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 13]

type Item = T

The array’s element type

const CAPACITY: usize = 13usize

The array’s element capacity

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

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

impl<T> Array for [T; 13]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 13usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 13]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 131072]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 14]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 14]

type Item = T

The array’s element type

const CAPACITY: usize = 14usize

The array’s element capacity

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

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

impl<T> Array for [T; 14]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 14usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 14]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 15]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 15]

type Item = T

The array’s element type

const CAPACITY: usize = 15usize

The array’s element capacity

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

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

impl<T> Array for [T; 15]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 15usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 15]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 1536]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 16]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 16]

type Item = T

The array’s element type

const CAPACITY: usize = 16usize

The array’s element capacity

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

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

impl<T> Array for [T; 16]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 16usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 16]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 160]

type Item = T

The array’s element type

const CAPACITY: usize = 160usize

The array’s element capacity

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

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

impl<T> Array for [T; 16384]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 16384]

type Item = T

The array’s element type

const CAPACITY: usize = 16_384usize

The array’s element capacity

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

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

impl<T> Array for [T; 17]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 17]

type Item = T

The array’s element type

const CAPACITY: usize = 17usize

The array’s element capacity

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

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

impl<T> Array for [T; 17]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 17usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 17]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 18]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 18]

type Item = T

The array’s element type

const CAPACITY: usize = 18usize

The array’s element capacity

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

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

impl<T> Array for [T; 18]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 18usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 18]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 19]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 19]

type Item = T

The array’s element type

const CAPACITY: usize = 19usize

The array’s element capacity

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

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

impl<T> Array for [T; 19]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 19usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 19]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 192]

type Item = T

The array’s element type

const CAPACITY: usize = 192usize

The array’s element capacity

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

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

impl<T> Array for [T; 2]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 2]

type Item = T

The array’s element type

const CAPACITY: usize = 2usize

The array’s element capacity

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

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

impl<T> Array for [T; 2]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 2usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 2]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 20]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 20]

type Item = T

The array’s element type

const CAPACITY: usize = 20usize

The array’s element capacity

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

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

impl<T> Array for [T; 20]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 20usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 20]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 200]

type Item = T

The array’s element type

const CAPACITY: usize = 200usize

The array’s element capacity

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

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

impl<T> Array for [T; 2048]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 2048]

type Item = T

The array’s element type

const CAPACITY: usize = 2_048usize

The array’s element capacity

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

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

impl<T> Array for [T; 2048]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 2_048usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 2048]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 21]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 21]

type Item = T

The array’s element type

const CAPACITY: usize = 21usize

The array’s element capacity

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

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

impl<T> Array for [T; 21]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 21usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 21]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 22]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 22]

type Item = T

The array’s element type

const CAPACITY: usize = 22usize

The array’s element capacity

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

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

impl<T> Array for [T; 22]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 22usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 22]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 224]

type Item = T

The array’s element type

const CAPACITY: usize = 224usize

The array’s element capacity

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

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

impl<T> Array for [T; 23]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 23]

type Item = T

The array’s element type

const CAPACITY: usize = 23usize

The array’s element capacity

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

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

impl<T> Array for [T; 23]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 23usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 23]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 24]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 24]

type Item = T

The array’s element type

const CAPACITY: usize = 24usize

The array’s element capacity

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

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

impl<T> Array for [T; 24]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 24usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 24]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 24576]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 25]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 25]

type Item = T

The array’s element type

const CAPACITY: usize = 25usize

The array’s element capacity

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

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

impl<T> Array for [T; 25]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 25usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 25]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 256]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 256]

type Item = T

The array’s element type

const CAPACITY: usize = 256usize

The array’s element capacity

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

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

impl<T> Array for [T; 256]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 256usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 256]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 26]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 26]

type Item = T

The array’s element type

const CAPACITY: usize = 26usize

The array’s element capacity

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

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

impl<T> Array for [T; 26]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 26usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 26]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 262144]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 27]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 27]

type Item = T

The array’s element type

const CAPACITY: usize = 27usize

The array’s element capacity

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

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

impl<T> Array for [T; 27]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 27usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 27]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 28]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 28]

type Item = T

The array’s element type

const CAPACITY: usize = 28usize

The array’s element capacity

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

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

impl<T> Array for [T; 28]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 28usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 28]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 29]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 29]

type Item = T

The array’s element type

const CAPACITY: usize = 29usize

The array’s element capacity

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

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

impl<T> Array for [T; 29]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 29usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 29]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 3]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 3]

type Item = T

The array’s element type

const CAPACITY: usize = 3usize

The array’s element capacity

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

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

impl<T> Array for [T; 3]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 3usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 3]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 30]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 30]

type Item = T

The array’s element type

const CAPACITY: usize = 30usize

The array’s element capacity

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

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

impl<T> Array for [T; 30]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 30usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 30]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 31]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 31]

type Item = T

The array’s element type

const CAPACITY: usize = 31usize

The array’s element capacity

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

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

impl<T> Array for [T; 31]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 31usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 31]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 32]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 32]

type Item = T

The array’s element type

const CAPACITY: usize = 32usize

The array’s element capacity

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

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

impl<T> Array for [T; 32]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 32usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 32]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 32768]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 32768]

type Item = T

The array’s element type

const CAPACITY: usize = 32_768usize

The array’s element capacity

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

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

impl<T> Array for [T; 33]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 33usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 33]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 36]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 384]

type Item = T

The array’s element type

const CAPACITY: usize = 384usize

The array’s element capacity

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

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

impl<T> Array for [T; 393216]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 4]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 4]

type Item = T

The array’s element type

const CAPACITY: usize = 4usize

The array’s element capacity

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

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

impl<T> Array for [T; 4]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 4usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 4]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 40]

type Item = T

The array’s element type

const CAPACITY: usize = 40usize

The array’s element capacity

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

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

impl<T> Array for [T; 4096]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 4096]

type Item = T

The array’s element type

const CAPACITY: usize = 4_096usize

The array’s element capacity

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

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

impl<T> Array for [T; 4096]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 4_096usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 4096]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 48]

type Item = T

The array’s element type

const CAPACITY: usize = 48usize

The array’s element capacity

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

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

impl<T> Array for [T; 5]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 5]

type Item = T

The array’s element type

const CAPACITY: usize = 5usize

The array’s element capacity

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

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

impl<T> Array for [T; 5]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 5usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 5]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 50]

type Item = T

The array’s element type

const CAPACITY: usize = 50usize

The array’s element capacity

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

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

impl<T> Array for [T; 512]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 512]

type Item = T

The array’s element type

const CAPACITY: usize = 512usize

The array’s element capacity

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

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

impl<T> Array for [T; 512]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 512usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 512]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 524288]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 56]

type Item = T

The array’s element type

const CAPACITY: usize = 56usize

The array’s element capacity

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

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

impl<T> Array for [T; 6]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 6]

type Item = T

The array’s element type

const CAPACITY: usize = 6usize

The array’s element capacity

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

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

impl<T> Array for [T; 6]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 6usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 6]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 64]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 64]

type Item = T

The array’s element type

const CAPACITY: usize = 64usize

The array’s element capacity

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

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

impl<T> Array for [T; 64]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 64usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 64]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 65536]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 65536]

type Item = T

The array’s element type

const CAPACITY: usize = 65_536usize

The array’s element capacity

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

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

impl<T> Array for [T; 7]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 7]

type Item = T

The array’s element type

const CAPACITY: usize = 7usize

The array’s element capacity

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

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

impl<T> Array for [T; 7]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 7usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 7]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 72]

type Item = T

The array’s element type

const CAPACITY: usize = 72usize

The array’s element capacity

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

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

impl<T> Array for [T; 768]

type Item = T

The array’s element type

const CAPACITY: usize = 768usize

The array’s element capacity

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

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

impl<T> Array for [T; 8]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 8]

type Item = T

The array’s element type

const CAPACITY: usize = 8usize

The array’s element capacity

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

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

impl<T> Array for [T; 8]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 8usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 8]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 8192]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 8192]

type Item = T

The array’s element type

const CAPACITY: usize = 8_192usize

The array’s element capacity

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

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

impl<T> Array for [T; 9]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 9]

type Item = T

The array’s element type

const CAPACITY: usize = 9usize

The array’s element capacity

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

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

impl<T> Array for [T; 9]where T: Default,

type Item = T

The type of the items in the thing.

const CAPACITY: usize = 9usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing.

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

Gives a unique slice over the whole thing.

fn default() -> [T; 9]

Create a default-initialized instance of ourself, similar to the Default trait, but implemented for the same range of sizes as [Array].

impl<T> Array for [T; 96]

type Item = T

The type of the array’s elements.

fn size() -> usize

Returns the number of items the array can hold.

impl<T> Array for [T; 96]

type Item = T

The array’s element type

const CAPACITY: usize = 96usize

The array’s element capacity

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

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

impl<T> ArrayLike for [T; 0]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 0]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 1]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 1]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 128]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 128]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 16]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 16]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 192]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 192]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 2]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 2]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 3]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 3]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 32]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 32]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 4]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 4]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 64]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 64]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 8]

type Item = T

Type of the elements being stored.

impl<T> ArrayLike for [T; 8]

type Item = T

Type of the elements being stored.

impl<const N: usize> AsBufRead for [u8; N]

fn len(&self) -> usize

The length of this buffer.

fn is_empty(&self) -> bool

Is this buffer empty?

fn read_lock(&self) -> ReadGuard<'_>

Obtain read access to the underlying buffer.

fn try_unwrap(self: Arc<[u8; N], Global>) -> Result<Box<[u8], Global>, BufRead>

Attempt to extract the inner contents of this buf without cloning. If this memory is locked or there are clones of this reference, the unwrap will fail, returning a BufRead instance.

impl<const N: usize> AsBufReadSized<N> for [u8; N]

fn read_lock_sized(&self) -> ReadGuardSized<'_, N>

Obtain read access to the underlying buffer.

fn into_read_unsized(self: Arc<[u8; N], Global>) -> BufRead

Convert to an unsized BufRead instance without cloning internal data and without changing memory locking strategy.

fn try_unwrap_sized( self: Arc<[u8; N], Global> ) -> Result<[u8; N], BufReadSized<N>>

Attempt to extract the inner contents of this buf without cloning. If this memory is locked or there are clones of this reference, the unwrap will fail, returning a BufRead instance.

impl<T> AsByteSliceMut for [T; 0]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 0]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 1]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 1]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 10]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 10]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 1024]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 1024]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 11]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 11]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 12]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 12]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 128]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 128]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 13]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 13]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 14]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 14]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 15]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 15]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 16]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 16]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 17]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 17]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 18]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 18]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 19]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 19]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 2]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 2]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 20]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 20]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 2048]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 2048]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 21]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 21]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 22]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 22]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 23]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 23]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 24]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 24]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 25]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 25]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 256]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 256]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 26]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 26]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 27]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 27]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 28]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 28]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 29]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 29]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 3]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 3]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 30]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 30]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 31]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 31]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 32]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 32]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 4]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 4]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 4096]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 4096]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 5]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 5]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 512]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 512]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 6]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 6]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 64]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 64]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 7]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 7]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 8]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 8]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 9]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl<T> AsByteSliceMut for [T; 9]where [T]: AsByteSliceMut,

fn as_byte_slice_mut(&mut self) -> &mut [u8]

Return a mutable reference to self as a byte slice

fn to_le(&mut self)

Call to_le on each element (i.e. byte-swap on Big Endian platforms).

impl AsBytes for [u8; 0]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 1]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 10]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 11]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 12]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 13]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 14]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 15]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 16]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 17]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 18]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 19]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 2]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 20]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 21]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 22]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 23]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 24]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 25]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 26]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 27]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 28]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 29]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 3]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 30]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 31]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 32]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 4]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 5]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 6]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 7]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 8]

fn as_bytes(&self) -> &[u8]

impl AsBytes for [u8; 9]

fn as_bytes(&self) -> &[u8]

impl<T, const N: usize> AsMut<[T]> for [T; N]

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, const N: usize> AsRef<[T]> for [T; N]

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, const N: usize> Borrow<[T]> for [T; N]

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

Immutably borrows from an owned value.

impl<T, const N: usize> BorrowMut<[T]> for [T; N]

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

Mutably borrows from an owned value.

impl<T, const N: usize> Clone for [T; N]where T: Clone,

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

Returns a copy of the value.

fn clone_from(&mut self, other: &[T; N])

Performs copy-assignment from source.

impl<const LEN: usize, C> ContainsToken<C> for [u8; LEN]where C: AsChar,

fn contains_token(&self, token: C) -> bool

Returns true if self contains the token

impl<T, const N: usize> Debug for [T; N]where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for [T; 0]

fn default() -> [T; 0]

Returns the “default value” for a type.

impl<T> Default for [T; 1]where T: Default,

fn default() -> [T; 1]

Returns the “default value” for a type.

impl<T> Default for [T; 10]where T: Default,

fn default() -> [T; 10]

Returns the “default value” for a type.

impl<T> Default for [T; 11]where T: Default,

fn default() -> [T; 11]

Returns the “default value” for a type.

impl<T> Default for [T; 12]where T: Default,

fn default() -> [T; 12]

Returns the “default value” for a type.

impl<T> Default for [T; 13]where T: Default,

fn default() -> [T; 13]

Returns the “default value” for a type.

impl<T> Default for [T; 14]where T: Default,

fn default() -> [T; 14]

Returns the “default value” for a type.

impl<T> Default for [T; 15]where T: Default,

fn default() -> [T; 15]

Returns the “default value” for a type.

impl<T> Default for [T; 16]where T: Default,

fn default() -> [T; 16]

Returns the “default value” for a type.

impl<T> Default for [T; 17]where T: Default,

fn default() -> [T; 17]

Returns the “default value” for a type.

impl<T> Default for [T; 18]where T: Default,

fn default() -> [T; 18]

Returns the “default value” for a type.

impl<T> Default for [T; 19]where T: Default,

fn default() -> [T; 19]

Returns the “default value” for a type.

impl<T> Default for [T; 2]where T: Default,

fn default() -> [T; 2]

Returns the “default value” for a type.

impl<T> Default for [T; 20]where T: Default,

fn default() -> [T; 20]

Returns the “default value” for a type.

impl<T> Default for [T; 21]where T: Default,

fn default() -> [T; 21]

Returns the “default value” for a type.

impl<T> Default for [T; 22]where T: Default,

fn default() -> [T; 22]

Returns the “default value” for a type.

impl<T> Default for [T; 23]where T: Default,

fn default() -> [T; 23]

Returns the “default value” for a type.

impl<T> Default for [T; 24]where T: Default,

fn default() -> [T; 24]

Returns the “default value” for a type.

impl<T> Default for [T; 25]where T: Default,

fn default() -> [T; 25]

Returns the “default value” for a type.

impl<T> Default for [T; 26]where T: Default,

fn default() -> [T; 26]

Returns the “default value” for a type.

impl<T> Default for [T; 27]where T: Default,

fn default() -> [T; 27]

Returns the “default value” for a type.

impl<T> Default for [T; 28]where T: Default,

fn default() -> [T; 28]

Returns the “default value” for a type.

impl<T> Default for [T; 29]where T: Default,

fn default() -> [T; 29]

Returns the “default value” for a type.

impl<T> Default for [T; 3]where T: Default,

fn default() -> [T; 3]

Returns the “default value” for a type.

impl<T> Default for [T; 30]where T: Default,

fn default() -> [T; 30]

Returns the “default value” for a type.

impl<T> Default for [T; 31]where T: Default,

fn default() -> [T; 31]

Returns the “default value” for a type.

impl<T> Default for [T; 32]where T: Default,

fn default() -> [T; 32]

Returns the “default value” for a type.

impl<T> Default for [T; 4]where T: Default,

fn default() -> [T; 4]

Returns the “default value” for a type.

impl<T> Default for [T; 5]where T: Default,

fn default() -> [T; 5]

Returns the “default value” for a type.

impl<T> Default for [T; 6]where T: Default,

fn default() -> [T; 6]

Returns the “default value” for a type.

impl<T> Default for [T; 7]where T: Default,

fn default() -> [T; 7]

Returns the “default value” for a type.

impl<T> Default for [T; 8]where T: Default,

fn default() -> [T; 8]

Returns the “default value” for a type.

impl<T> Default for [T; 9]where T: Default,

fn default() -> [T; 9]

Returns the “default value” for a type.

impl<T, D, const N: usize> Deserialize<[T; N], D> for [<T as Archive>::Archived; N]where T: Archive, D: Fallible + ?Sized, <T as Archive>::Archived: Deserialize<T, D>,

fn deserialize( &self, deserializer: &mut D ) -> Result<[T; N], <D as Fallible>::Error>

Deserializes using the given deserializer

impl<'de, T> Deserialize<'de> for [T; 0]

fn deserialize<D>( deserializer: D ) -> Result<[T; 0], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 1]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 1], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 10]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 10], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 11]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 11], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 12]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 12], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 13]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 13], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 14]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 14], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 15]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 15], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 16]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 16], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 17]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 17], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 18]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 18], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 19]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 19], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 2]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 2], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 20]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 20], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 21]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 21], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 22]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 22], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 23]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 23], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 24]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 24], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 25]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 25], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 26]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 26], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 27]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 27], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 28]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 28], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 29]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 29], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 3]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 3], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 30]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 30], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 31]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 31], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 32]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 32], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 4]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 4], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 5]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 5], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 6]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 6], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 7]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 7], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 8]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 8], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for [T; 9]where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<[T; 9], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T, As, const N: usize> DeserializeAs<'de, [T; N]> for [As; N]where As: DeserializeAs<'de, T>,

fn deserialize_as<D>( deserializer: D ) -> Result<[T; N], <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Fill for [T; 0]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 1]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 10]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 1024]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 11]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 12]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 128]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 13]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 14]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 15]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 16]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 17]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 18]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 19]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 2]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 20]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 2048]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 21]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 22]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 23]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 24]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 25]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 256]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 26]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 27]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 28]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 29]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 3]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 30]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 31]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 32]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 4]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 4096]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 5]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 512]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 6]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 64]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 7]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 8]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<T> Fill for [T; 9]where [T]: Fill,

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>where R: Rng + ?Sized,

Fill self with random data

impl<'a> FindToken<&'a u8> for [u8; 0]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 1]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 10]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 11]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 12]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 13]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 14]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 15]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 16]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 17]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 18]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 19]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 2]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 20]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 21]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 22]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 23]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 24]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 25]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 26]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 27]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 28]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 29]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 3]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 30]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 31]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 32]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 4]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 5]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 6]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 7]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 8]

fn find_token(&self, token: &u8) -> bool

impl<'a> FindToken<&'a u8> for [u8; 9]

fn find_token(&self, token: &u8) -> bool

impl FindToken<u8> for [u8; 0]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 1]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 10]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 11]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 12]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 13]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 14]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 15]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 16]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 17]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 18]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 19]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 2]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 20]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 21]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 22]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 23]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 24]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 25]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 26]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 27]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 28]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 29]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 3]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 30]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 31]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 32]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 4]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 5]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 6]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 7]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 8]

fn find_token(&self, token: u8) -> bool

impl FindToken<u8> for [u8; 9]

fn find_token(&self, token: u8) -> bool

impl<T> From<(T,)> for [T; 1]

fn from(tuple: (T,)) -> [T; 1]

Converts to this type from the input type.

impl<T> From<(T, T)> for [T; 2]

fn from(tuple: (T, T)) -> [T; 2]

Converts to this type from the input type.

impl<T> From<(T, T, T)> for [T; 3]

fn from(tuple: (T, T, T)) -> [T; 3]

Converts to this type from the input type.

impl<T> From<(T, T, T, T)> for [T; 4]

fn from(tuple: (T, T, T, T)) -> [T; 4]

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T)> for [T; 5]

fn from(tuple: (T, T, T, T, T)) -> [T; 5]

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T)> for [T; 6]

fn from(tuple: (T, T, T, T, T, T)) -> [T; 6]

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T)> for [T; 7]

fn from(tuple: (T, T, T, T, T, T, T)) -> [T; 7]

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T)> for [T; 8]

fn from(tuple: (T, T, T, T, T, T, T, T)) -> [T; 8]

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T, T)> for [T; 9]

fn from(tuple: (T, T, T, T, T, T, T, T, T)) -> [T; 9]

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T, T, T)> for [T; 10]

fn from(tuple: (T, T, T, T, T, T, T, T, T, T)) -> [T; 10]

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T)> for [T; 11]

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T)) -> [T; 11]

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 12]

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T, T)) -> [T; 12]

Converts to this type from the input type.

impl From<AutoSimd<[u8; 16]>> for [u8; 16]

fn from(val: AutoSimd<[u8; 16]>) -> [u8; 16]

Converts to this type from the input type.

impl From<AutoSimd<[u8; 2]>> for [u8; 2]

fn from(val: AutoSimd<[u8; 2]>) -> [u8; 2]

Converts to this type from the input type.

impl From<AutoSimd<[u8; 32]>> for [u8; 32]

fn from(val: AutoSimd<[u8; 32]>) -> [u8; 32]

Converts to this type from the input type.

impl From<AutoSimd<[u8; 4]>> for [u8; 4]

fn from(val: AutoSimd<[u8; 4]>) -> [u8; 4]

Converts to this type from the input type.

impl From<AutoSimd<[u8; 8]>> for [u8; 8]

fn from(val: AutoSimd<[u8; 8]>) -> [u8; 8]

Converts to this type from the input type.

impl From<BigEndian<u32>> for [u8; 4]

fn from(encoded: BigEndian<u32>) -> [u8; 4]

Converts to this type from the input type.

impl From<BigEndian<u64>> for [u8; 8]

fn from(encoded: BigEndian<u64>) -> [u8; 8]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 1024]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>> ) -> [T; 1024]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 512]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>> ) -> [T; 512]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 1000]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>> ) -> [T; 1000]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 256]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>> ) -> [T; 256]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 300]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>> ) -> [T; 300]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 400]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>> ) -> [T; 400]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 500]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>> ) -> [T; 500]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 128]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>> ) -> [T; 128]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>> for [T; 200]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>> ) -> [T; 200]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 64]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>> ) -> [T; 64]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>> for [T; 70]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>> ) -> [T; 70]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 80]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>> ) -> [T; 80]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>> for [T; 90]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>> ) -> [T; 90]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 100]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>> ) -> [T; 100]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>> for [T; 32]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>> ) -> [T; 32]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>> for [T; 33]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>> ) -> [T; 33]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>> for [T; 34]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>> ) -> [T; 34]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>> for [T; 35]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>> ) -> [T; 35]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 36]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>> ) -> [T; 36]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>> for [T; 37]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>> ) -> [T; 37]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>> for [T; 38]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>> ) -> [T; 38]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>> for [T; 39]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>> ) -> [T; 39]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 40]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>> ) -> [T; 40]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>> for [T; 41]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>> ) -> [T; 41]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>> for [T; 42]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>> ) -> [T; 42]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>> for [T; 43]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>> ) -> [T; 43]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 44]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>> ) -> [T; 44]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>> for [T; 45]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>> ) -> [T; 45]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>> for [T; 46]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>> ) -> [T; 46]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>> for [T; 47]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>> ) -> [T; 47]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>> for [T; 48]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>> ) -> [T; 48]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>> for [T; 49]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>> ) -> [T; 49]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>> for [T; 50]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>> ) -> [T; 50]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>> for [T; 51]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>> ) -> [T; 51]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 52]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>> ) -> [T; 52]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>> for [T; 53]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>> ) -> [T; 53]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>> for [T; 54]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>> ) -> [T; 54]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>> for [T; 55]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>> ) -> [T; 55]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>> for [T; 56]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>> ) -> [T; 56]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>> for [T; 57]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>> ) -> [T; 57]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>> for [T; 58]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>> ) -> [T; 58]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>> for [T; 59]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>> ) -> [T; 59]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>> for [T; 60]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>> ) -> [T; 60]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>> for [T; 61]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>> ) -> [T; 61]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>> for [T; 62]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>> ) -> [T; 62]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>> for [T; 63]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>> ) -> [T; 63]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>> for [T; 16]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>> ) -> [T; 16]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>> for [T; 17]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>> ) -> [T; 17]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>> for [T; 18]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>> ) -> [T; 18]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>> for [T; 19]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>> ) -> [T; 19]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>> for [T; 20]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>> ) -> [T; 20]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>> for [T; 21]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>> ) -> [T; 21]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>> for [T; 22]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>> ) -> [T; 22]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>> for [T; 23]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>> ) -> [T; 23]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>> for [T; 24]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>> ) -> [T; 24]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>> for [T; 25]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>> ) -> [T; 25]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>> for [T; 26]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>> ) -> [T; 26]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>> for [T; 27]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>> ) -> [T; 27]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>> for [T; 28]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>> ) -> [T; 28]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>> for [T; 29]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>> ) -> [T; 29]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>> for [T; 30]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>> ) -> [T; 30]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>> for [T; 31]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>> ) -> [T; 31]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>> for [T; 8]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> ) -> [T; 8]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>> for [T; 9]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>> ) -> [T; 9]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>> for [T; 10]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> ) -> [T; 10]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>> for [T; 11]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>> ) -> [T; 11]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>> for [T; 12]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>> ) -> [T; 12]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>> for [T; 13]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>> ) -> [T; 13]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>> for [T; 14]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>> ) -> [T; 14]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>> for [T; 15]

fn from( sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> ) -> [T; 15]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>> for [T; 4]

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>) -> [T; 4]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>> for [T; 5]

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>) -> [T; 5]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>> for [T; 6]

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>) -> [T; 6]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>> for [T; 7]

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>) -> [T; 7]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B0>>> for [T; 2]

fn from(sel: GenericArray<T, UInt<UInt<UTerm, B1>, B0>>) -> [T; 2]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B1>>> for [T; 3]

fn from(sel: GenericArray<T, UInt<UInt<UTerm, B1>, B1>>) -> [T; 3]

Converts to this type from the input type.

impl<T> From<GenericArray<T, UInt<UTerm, B1>>> for [T; 1]

fn from(sel: GenericArray<T, UInt<UTerm, B1>>) -> [T; 1]

Converts to this type from the input type.

impl From<LittleEndian<u32>> for [u8; 4]

fn from(encoded: LittleEndian<u32>) -> [u8; 4]

Converts to this type from the input type.

impl From<LittleEndian<u64>> for [u8; 8]

fn from(encoded: LittleEndian<u64>) -> [u8; 8]

Converts to this type from the input type.

impl<T, const D: usize> From<Matrix<T, Const<1>, Const<D>, ArrayStorage<T, 1, D>>> for [T; D]where T: Scalar, Const<D>: IsNotStaticOne,

fn from(vec: Matrix<T, Const<1>, Const<D>, ArrayStorage<T, 1, D>>) -> [T; D]

Converts to this type from the input type.

impl<T, const D: usize> From<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for [T; D]where T: Scalar,

fn from(vec: Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>) -> [T; D]

Converts to this type from the input type.

impl<T, const D: usize> From<OPoint<T, Const<D>>> for [T; D]where T: Scalar,

fn from(p: OPoint<T, Const<D>>) -> [T; D]

Converts to this type from the input type.

impl<T, const N: usize> From<Simd<T, N>> for [T; N]where LaneCount<N>: SupportedLaneCount, T: SimdElement,

fn from(vector: Simd<T, N>) -> [T; N]

Converts to this type from the input type.

impl<T, const D: usize> From<Translation<T, D>> for [T; D]where T: Scalar,

fn from(t: Translation<T, D>) -> [T; D]

Converts to this type from the input type.

impl From<m128i> for [u8; 16]

fn from(m: m128i) -> [u8; 16]

Converts to this type from the input type.

impl From<m256i> for [u8; 32]

fn from(m: m256i) -> [u8; 32]

Converts to this type from the input type.

impl From<u8x16> for [u8; 16]

fn from(simd: u8x16) -> [u8; 16]

Converts to this type from the input type.

impl<const N: usize> FromSql for [u8; N]

fn column_result(value: ValueRef<'_>) -> Result<[u8; N], FromSqlError>

Converts SQLite value into Rust value.

impl<T, const N: usize> Hash for [T; N]where T: Hash,

The hash of an array is the same as that of the corresponding slice, as required by the Borrow implementation.

use std::hash::BuildHasher;

let b = std::collections::hash_map::RandomState::new();
let a: [u8; 3] = [0xa8, 0x3c, 0x09];
let s: &[u8] = &[0xa8, 0x3c, 0x09];
assert_eq!(b.hash_one(a), b.hash_one(s));

fn hash<H>(&self, state: &mut H)where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, I, const N: usize> Index<I> for [T; N]where [T]: Index<I>,

type Output = <[T] as Index<I>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &<[T; N] as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<T, I, const N: usize> IndexMut<I> for [T; N]where [T]: IndexMut<I>,

fn index_mut(&mut self, index: I) -> &mut <[T; N] as Index<I>>::Output

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

impl InputLength for [u8; 0]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 1]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 10]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 11]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 12]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 13]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 14]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 15]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 16]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 17]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 18]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 19]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 2]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 20]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 21]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 22]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 23]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 24]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 25]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 26]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 27]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 28]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 29]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 3]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 30]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 31]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 32]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 4]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 5]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 6]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 7]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 8]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl InputLength for [u8; 9]

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl<T, const N: usize> IntoIterator for [T; N]

fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the array (from start to end). The array cannot be used after calling this unless T implements Copy, so the whole array is copied.

Arrays have special behavior when calling .into_iter() prior to the 2021 edition – see the array Editions section for more information.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, N>

Which kind of iterator are we turning this into?

impl<T, const N: usize> IntoParallelIterator for [T; N]where T: Send,

type Item = T

The type of item that the parallel iterator will produce.

type Iter = IntoIter<T, N>

The parallel iterator type that will be created.

fn into_par_iter(self) -> <[T; N] as IntoParallelIterator>::Iter

Converts self into a parallel iterator.

impl<T, const N: usize> MemoryUsage for [T; N]where T: MemoryUsage,

fn size_of_val(&self, tracker: &mut dyn MemoryUsageTracker) -> usize

Returns the size of the referenced value in bytes.

impl<T, const N: usize> Ord for [T; N]where T: Ord,

Implements comparison of arrays lexicographically.

fn cmp(&self, other: &[T; N]) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<A, B, const N: usize> PartialEq<&[B]> for [A; N]where A: PartialEq<B>,

fn eq(&self, other: &&[B]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&[B]) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, B, const N: usize> PartialEq<&mut [B]> for [A; N]where A: PartialEq<B>,

fn eq(&self, other: &&mut [B]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&mut [B]) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, B, const N: usize> PartialEq<[B]> for [A; N]where A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B]) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N]where A: PartialEq<B>,

fn eq(&self, other: &[B; N]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; N]) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U, const N: usize> PartialEq<ArchivedVec<T>> for [U; N]where T: PartialEq<U>,

fn eq(&self, other: &ArchivedVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U, const N: usize> PartialEq<RawArchivedVec<T>> for [U; N]where T: PartialEq<U>,

fn eq(&self, other: &RawArchivedVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, const N: usize> PartialOrd<[T; N]> for [T; N]where T: PartialOrd<T>,

fn partial_cmp(&self, other: &[T; N]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &[T; N]) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &[T; N]) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn ge(&self, other: &[T; N]) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

fn gt(&self, other: &[T; N]) -> bool

This method tests greater than (for self and other) and is used by the > operator.

impl<const N: usize> Replacer for [u8; N]

fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8, Global>)

Appends possibly empty data to dst to replace the current match.

fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>>

Return a fixed unchanging replacement byte string.

fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self>

Returns a type that implements Replacer, but that borrows and wraps this Replacer.

impl<T, S, const N: usize> Serialize<S> for [T; N]where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S ) -> Result<<[T; N] as Archive>::Resolver, <S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<T> Serialize for [T; 0]

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 1]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 10]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 11]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 12]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 13]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 14]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 15]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 16]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 17]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 18]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 19]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 2]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 20]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 21]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 22]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 23]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 24]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 25]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 26]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 27]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 28]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 29]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 3]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 30]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 31]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 32]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 4]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 5]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 6]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 7]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 8]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for [T; 9]where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, As, const N: usize> SerializeAs<[T; N]> for [As; N]where As: SerializeAs<T>,

fn serialize_as<S>( array: &[T; N], serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, const LEN: usize> SliceLen for [T; LEN]

fn slice_len(&self) -> usize

Calculates the input length, as indicated by its name, and the name of the trait itself

impl<T, const N: usize> SlicePattern for [T; N]

type Item = T

🔬This is a nightly-only experimental API. (slice_pattern)

The element type of the slice being matched on.

fn as_slice(&self) -> &[<[T; N] as SlicePattern>::Item]

🔬This is a nightly-only experimental API. (slice_pattern)

Currently, the consumers of SlicePattern need a slice.

impl<const N: usize> ToSql for [u8; N]

fn to_sql(&self) -> Result<ToSqlOutput<'_>, Error>

Converts Rust value to SQLite value

impl<T, const N: usize> TryFrom<&[T]> for [T; N]where T: Copy,

Tries to create an array [T; N] by copying from a slice &[T]. Succeeds if slice.len() == N.

let bytes: [u8; 3] = [1, 0, 2];

let bytes_head: [u8; 2] = <[u8; 2]>::try_from(&bytes[0..2]).unwrap();
assert_eq!(1, u16::from_le_bytes(bytes_head));

let bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(bytes_tail));

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.

impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]where T: Copy,

Tries to create an array [T; N] by copying from a mutable slice &mut [T]. Succeeds if slice.len() == N.

let mut bytes: [u8; 3] = [1, 0, 2];

let bytes_head: [u8; 2] = <[u8; 2]>::try_from(&mut bytes[0..2]).unwrap();
assert_eq!(1, u16::from_le_bytes(bytes_head));

let bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(bytes_tail));

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &mut [T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.

impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]where A: Allocator,

fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>

Gets the entire contents of the Vec<T> as an array, if its size exactly matches that of the requested array.

Examples

assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));

If the length doesn’t match, the input comes back in Err:

let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));

If you’re fine with just getting a prefix of the Vec<T>, you can call .truncate(N) first.

let mut v = String::from("hello world").into_bytes();
v.sort();
v.truncate(2);
let [a, b]: [_; 2] = v.try_into().unwrap();
assert_eq!(a, b' ');
assert_eq!(b, b'd');

type Error = Vec<T, A>

The type returned in the event of a conversion error.

impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]where A: Allocator,

fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>

Gets the entire contents of the Vec<T> as an array, if its size exactly matches that of the requested array.

Examples

assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));

If the length doesn’t match, the input comes back in Err:

let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));

If you’re fine with just getting a prefix of the Vec<T>, you can call .truncate(N) first.

let mut v = String::from("hello world").into_bytes();
v.sort();
v.truncate(2);
let [a, b]: [_; 2] = v.try_into().unwrap();
assert_eq!(a, b' ');
assert_eq!(b, b'd');

type Error = Vec<T, A>

The type returned in the event of a conversion error.

impl<T> Zeroable for [T; 0]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 1]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 10]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 1024]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 11]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 12]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 128]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 13]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 14]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 15]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 16]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 17]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 18]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 19]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 2]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 20]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 2048]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 21]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 22]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 23]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 24]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 25]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 256]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 26]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 27]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 28]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 29]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 3]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 30]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 31]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 32]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 4]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 4096]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 48]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 5]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 512]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 6]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 64]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 7]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 8]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 9]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T> Zeroable for [T; 96]where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<Z, const N: usize> Zeroize for [Z; N]where Z: Zeroize,

Impl [Zeroize] on arrays of types that impl [Zeroize].

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<T, const N: usize> ConstParamTy for [T; N]where T: ConstParamTy,

impl<T, const N: usize> Copy for [T; N]where T: Copy,

impl<T, const N: usize> Eq for [T; N]where T: Eq,

impl<T> Params for [T; 1]where T: ToSql,

impl<T> Params for [T; 10]where T: ToSql,

impl<T> Params for [T; 11]where T: ToSql,

impl<T> Params for [T; 12]where T: ToSql,

impl<T> Params for [T; 13]where T: ToSql,

impl<T> Params for [T; 14]where T: ToSql,

impl<T> Params for [T; 15]where T: ToSql,

impl<T> Params for [T; 16]where T: ToSql,

impl<T> Params for [T; 17]where T: ToSql,

impl<T> Params for [T; 18]where T: ToSql,

impl<T> Params for [T; 19]where T: ToSql,

impl<T> Params for [T; 2]where T: ToSql,

impl<T> Params for [T; 20]where T: ToSql,

impl<T> Params for [T; 21]where T: ToSql,

impl<T> Params for [T; 22]where T: ToSql,

impl<T> Params for [T; 23]where T: ToSql,

impl<T> Params for [T; 24]where T: ToSql,

impl<T> Params for [T; 25]where T: ToSql,

impl<T> Params for [T; 26]where T: ToSql,

impl<T> Params for [T; 27]where T: ToSql,

impl<T> Params for [T; 28]where T: ToSql,

impl<T> Params for [T; 29]where T: ToSql,

impl<T> Params for [T; 3]where T: ToSql,

impl<T> Params for [T; 30]where T: ToSql,

impl<T> Params for [T; 31]where T: ToSql,

impl<T> Params for [T; 32]where T: ToSql,

impl<T> Params for [T; 4]where T: ToSql,

impl<T> Params for [T; 5]where T: ToSql,

impl<T> Params for [T; 6]where T: ToSql,

impl<T> Params for [T; 7]where T: ToSql,

impl<T> Params for [T; 8]where T: ToSql,

impl<T> Params for [T; 9]where T: ToSql,

impl<T> Pod for [T; 0]where T: Pod,

impl<T> Pod for [T; 1]where T: Pod,

impl<T> Pod for [T; 10]where T: Pod,

impl<T> Pod for [T; 1024]where T: Pod,

impl<T> Pod for [T; 11]where T: Pod,

impl<T> Pod for [T; 12]where T: Pod,

impl<T> Pod for [T; 128]where T: Pod,

impl<T> Pod for [T; 13]where T: Pod,

impl<T> Pod for [T; 14]where T: Pod,

impl<T> Pod for [T; 15]where T: Pod,

impl<T> Pod for [T; 16]where T: Pod,

impl<T> Pod for [T; 17]where T: Pod,

impl<T> Pod for [T; 18]where T: Pod,

impl<T> Pod for [T; 19]where T: Pod,

impl<T> Pod for [T; 2]where T: Pod,

impl<T> Pod for [T; 20]where T: Pod,

impl<T> Pod for [T; 2048]where T: Pod,

impl<T> Pod for [T; 21]where T: Pod,

impl<T> Pod for [T; 22]where T: Pod,

impl<T> Pod for [T; 23]where T: Pod,

impl<T> Pod for [T; 24]where T: Pod,

impl<T> Pod for [T; 25]where T: Pod,

impl<T> Pod for [T; 256]where T: Pod,

impl<T> Pod for [T; 26]where T: Pod,

impl<T> Pod for [T; 27]where T: Pod,

impl<T> Pod for [T; 28]where T: Pod,

impl<T> Pod for [T; 29]where T: Pod,

impl<T> Pod for [T; 3]where T: Pod,

impl<T> Pod for [T; 30]where T: Pod,

impl<T> Pod for [T; 31]where T: Pod,

impl<T> Pod for [T; 32]where T: Pod,

impl<T> Pod for [T; 4]where T: Pod,

impl<T> Pod for [T; 4096]where T: Pod,

impl<T> Pod for [T; 48]where T: Pod,

impl<T> Pod for [T; 5]where T: Pod,

impl<T> Pod for [T; 512]where T: Pod,

impl<T> Pod for [T; 6]where T: Pod,

impl<T> Pod for [T; 64]where T: Pod,

impl<T> Pod for [T; 7]where T: Pod,

impl<T> Pod for [T; 8]where T: Pod,

impl<T> Pod for [T; 9]where T: Pod,

impl<T> Pod for [T; 96]where T: Pod,

impl<T, const N: usize> StructuralEq for [T; N]

impl<T, const N: usize> StructuralPartialEq for [T; N]

impl<Z, const N: usize> ZeroizeOnDrop for [Z; N]where Z: ZeroizeOnDrop,

Impl [ZeroizeOnDrop] on arrays of types that impl [ZeroizeOnDrop].