Trait arraylib::ArrayAsRef

pub trait ArrayAsRef<'a>: Array where
    Self::Item: 'a, {
    type AsRef: Array<Item = &'a Self::Item>;
    type AsMut: Array<Item = &'a mut Self::Item>;
    fn as_ref_array(&'a self) -> Self::AsRef;
    fn as_mut_array(&'a mut self) -> Self::AsMut;
}

Trait for conversation between &[T; N] and [&T; N] (or &mut [T; N] and [&mut T; N])

Associated Types

type AsRef: Array<Item = &'a Self::Item>

Result of the 'shared' conversation, in other words [&T; N] (where T = Self::Item, N = Self::Size)

type AsMut: Array<Item = &'a mut Self::Item>

Result of the 'unique' conversation, in other words [&mut T; N] (where T = Self::Item, N = Self::Size)

Loading content...

Required methods

fn as_ref_array(&'a self) -> Self::AsRef

Convert &self to [&T; N] (where T = Self::Item, N = Self::Size)

Examples

use arraylib::ArrayAsRef;

let arr = [0, 1, 2, 3];
let ref_arr = arr.as_ref_array();
assert_eq!(ref_arr, [&0, &1, &2, &3]);
assert_eq!(arr, [0, 1, 2, 3]);

use arraylib::{ArrayAsRef, ArrayExt};

// Don't do like this, it's just an example
fn index_of<A>(a: &A, x: A::Item) -> Option<usize>
where
    for<'a> A: ArrayAsRef<'a>,
    A::Item: PartialEq,
{
    a.as_ref_array()
        .iter_move()
        .enumerate()
        .find(|&(_, it)| it == &x)
        .map(|(idx, _)| idx)
}

let arr = [-2, 1, -1, 2];
assert_eq!(index_of(&arr, 1), Some(1));
assert_eq!(index_of(&arr, 2), Some(3));
assert_eq!(index_of(&arr, 0), None);

NOTE: it's nighly recommended to use iterators when you need to perform more that one operation (e.g. map + as_ref) because iterators are lazy and ArrayAsRef isn't.

See also: as_mut_array

fn as_mut_array(&'a mut self) -> Self::AsMut

Convert &mut self to [&mut T; N] (where T = Self::Item, N = Self::Size)

Examples

use arraylib::ArrayAsRef;

let mut arr = [0, 1, 2, 3];
let ref_arr = arr.as_mut_array();
assert_eq!(ref_arr, [&mut 0, &mut 1, &mut 2, &mut 3]);
assert_eq!(arr, [0, 1, 2, 3]);

use arraylib::{ArrayAsRef, ArrayExt};

// Don't do like this, it's just an example
fn find_and_replace<A>(a: &mut A, find: &A::Item, replace: A::Item) -> A::Item
where
    for<'a> A: ArrayAsRef<'a>,
    A::Item: PartialEq,
{
    let mut x = a.as_mut_array().iter_move().find(|it| it == &find);
    match x {
        Some(ref mut inner) => core::mem::replace(inner, replace),
        None => replace,
    }
}

let mut arr = [-2, 1, -1, 2];
assert_eq!(find_and_replace(&mut arr, &1, 8), 1);
assert_eq!(arr, [-2, 8, -1, 2]);

NOTE: it's nighly recommended to use iterators when you need to perform more that one operation (e.g. map + as_ref) because iterators are lazy and ArrayAsRef isn't.

See also: as_ref_array

Loading content...

Implementors

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 0]

type AsMut = [&'a mut T; 0]

type AsRef = [&'a T; 0]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 1]

type AsMut = [&'a mut T; 1]

type AsRef = [&'a T; 1]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 2]

type AsMut = [&'a mut T; 2]

type AsRef = [&'a T; 2]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 3]

type AsMut = [&'a mut T; 3]

type AsRef = [&'a T; 3]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 4]

type AsMut = [&'a mut T; 4]

type AsRef = [&'a T; 4]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 5]

type AsMut = [&'a mut T; 5]

type AsRef = [&'a T; 5]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 6]

type AsMut = [&'a mut T; 6]

type AsRef = [&'a T; 6]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 7]

type AsMut = [&'a mut T; 7]

type AsRef = [&'a T; 7]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 8]

type AsMut = [&'a mut T; 8]

type AsRef = [&'a T; 8]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 9]

type AsMut = [&'a mut T; 9]

type AsRef = [&'a T; 9]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 10]

type AsMut = [&'a mut T; 10]

type AsRef = [&'a T; 10]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 11]

type AsMut = [&'a mut T; 11]

type AsRef = [&'a T; 11]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 12]

type AsMut = [&'a mut T; 12]

type AsRef = [&'a T; 12]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 13]

type AsMut = [&'a mut T; 13]

type AsRef = [&'a T; 13]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 14]

type AsMut = [&'a mut T; 14]

type AsRef = [&'a T; 14]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 15]

type AsMut = [&'a mut T; 15]

type AsRef = [&'a T; 15]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 16]

type AsMut = [&'a mut T; 16]

type AsRef = [&'a T; 16]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 17]

type AsMut = [&'a mut T; 17]

type AsRef = [&'a T; 17]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 18]

type AsMut = [&'a mut T; 18]

type AsRef = [&'a T; 18]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 19]

type AsMut = [&'a mut T; 19]

type AsRef = [&'a T; 19]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 20]

type AsMut = [&'a mut T; 20]

type AsRef = [&'a T; 20]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 21]

type AsMut = [&'a mut T; 21]

type AsRef = [&'a T; 21]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 22]

type AsMut = [&'a mut T; 22]

type AsRef = [&'a T; 22]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 23]

type AsMut = [&'a mut T; 23]

type AsRef = [&'a T; 23]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 24]

type AsMut = [&'a mut T; 24]

type AsRef = [&'a T; 24]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 25]

type AsMut = [&'a mut T; 25]

type AsRef = [&'a T; 25]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 26]

type AsMut = [&'a mut T; 26]

type AsRef = [&'a T; 26]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 27]

type AsMut = [&'a mut T; 27]

type AsRef = [&'a T; 27]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 28]

type AsMut = [&'a mut T; 28]

type AsRef = [&'a T; 28]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 29]

type AsMut = [&'a mut T; 29]

type AsRef = [&'a T; 29]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 30]

type AsMut = [&'a mut T; 30]

type AsRef = [&'a T; 30]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 31]

type AsMut = [&'a mut T; 31]

type AsRef = [&'a T; 31]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 32]

type AsMut = [&'a mut T; 32]

type AsRef = [&'a T; 32]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 33]

type AsMut = [&'a mut T; 33]

type AsRef = [&'a T; 33]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 34]

type AsMut = [&'a mut T; 34]

type AsRef = [&'a T; 34]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 35]

type AsMut = [&'a mut T; 35]

type AsRef = [&'a T; 35]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 36]

type AsMut = [&'a mut T; 36]

type AsRef = [&'a T; 36]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 37]

type AsMut = [&'a mut T; 37]

type AsRef = [&'a T; 37]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 38]

type AsMut = [&'a mut T; 38]

type AsRef = [&'a T; 38]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 39]

type AsMut = [&'a mut T; 39]

type AsRef = [&'a T; 39]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 40]

type AsMut = [&'a mut T; 40]

type AsRef = [&'a T; 40]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 41]

type AsMut = [&'a mut T; 41]

type AsRef = [&'a T; 41]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 42]

type AsMut = [&'a mut T; 42]

type AsRef = [&'a T; 42]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 43]

type AsMut = [&'a mut T; 43]

type AsRef = [&'a T; 43]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 44]

type AsMut = [&'a mut T; 44]

type AsRef = [&'a T; 44]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 45]

type AsMut = [&'a mut T; 45]

type AsRef = [&'a T; 45]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 46]

type AsMut = [&'a mut T; 46]

type AsRef = [&'a T; 46]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 47]

type AsMut = [&'a mut T; 47]

type AsRef = [&'a T; 47]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 48]

type AsMut = [&'a mut T; 48]

type AsRef = [&'a T; 48]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 49]

type AsMut = [&'a mut T; 49]

type AsRef = [&'a T; 49]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 50]

type AsMut = [&'a mut T; 50]

type AsRef = [&'a T; 50]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 51]

type AsMut = [&'a mut T; 51]

type AsRef = [&'a T; 51]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 52]

type AsMut = [&'a mut T; 52]

type AsRef = [&'a T; 52]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 53]

type AsMut = [&'a mut T; 53]

type AsRef = [&'a T; 53]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 54]

type AsMut = [&'a mut T; 54]

type AsRef = [&'a T; 54]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 55]

type AsMut = [&'a mut T; 55]

type AsRef = [&'a T; 55]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 56]

type AsMut = [&'a mut T; 56]

type AsRef = [&'a T; 56]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 57]

type AsMut = [&'a mut T; 57]

type AsRef = [&'a T; 57]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 58]

type AsMut = [&'a mut T; 58]

type AsRef = [&'a T; 58]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 59]

type AsMut = [&'a mut T; 59]

type AsRef = [&'a T; 59]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 60]

type AsMut = [&'a mut T; 60]

type AsRef = [&'a T; 60]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 61]

type AsMut = [&'a mut T; 61]

type AsRef = [&'a T; 61]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 62]

type AsMut = [&'a mut T; 62]

type AsRef = [&'a T; 62]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 63]

type AsMut = [&'a mut T; 63]

type AsRef = [&'a T; 63]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 64]

type AsMut = [&'a mut T; 64]

type AsRef = [&'a T; 64]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 65]

type AsMut = [&'a mut T; 65]

type AsRef = [&'a T; 65]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 66]

type AsMut = [&'a mut T; 66]

type AsRef = [&'a T; 66]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 67]

type AsMut = [&'a mut T; 67]

type AsRef = [&'a T; 67]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 68]

type AsMut = [&'a mut T; 68]

type AsRef = [&'a T; 68]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 69]

type AsMut = [&'a mut T; 69]

type AsRef = [&'a T; 69]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 70]

type AsMut = [&'a mut T; 70]

type AsRef = [&'a T; 70]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 71]

type AsMut = [&'a mut T; 71]

type AsRef = [&'a T; 71]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 72]

type AsMut = [&'a mut T; 72]

type AsRef = [&'a T; 72]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 73]

type AsMut = [&'a mut T; 73]

type AsRef = [&'a T; 73]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 74]

type AsMut = [&'a mut T; 74]

type AsRef = [&'a T; 74]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 75]

type AsMut = [&'a mut T; 75]

type AsRef = [&'a T; 75]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 76]

type AsMut = [&'a mut T; 76]

type AsRef = [&'a T; 76]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 77]

type AsMut = [&'a mut T; 77]

type AsRef = [&'a T; 77]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 78]

type AsMut = [&'a mut T; 78]

type AsRef = [&'a T; 78]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 79]

type AsMut = [&'a mut T; 79]

type AsRef = [&'a T; 79]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 80]

type AsMut = [&'a mut T; 80]

type AsRef = [&'a T; 80]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 81]

type AsMut = [&'a mut T; 81]

type AsRef = [&'a T; 81]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 82]

type AsMut = [&'a mut T; 82]

type AsRef = [&'a T; 82]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 83]

type AsMut = [&'a mut T; 83]

type AsRef = [&'a T; 83]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 84]

type AsMut = [&'a mut T; 84]

type AsRef = [&'a T; 84]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 85]

type AsMut = [&'a mut T; 85]

type AsRef = [&'a T; 85]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 86]

type AsMut = [&'a mut T; 86]

type AsRef = [&'a T; 86]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 87]

type AsMut = [&'a mut T; 87]

type AsRef = [&'a T; 87]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 88]

type AsMut = [&'a mut T; 88]

type AsRef = [&'a T; 88]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 89]

type AsMut = [&'a mut T; 89]

type AsRef = [&'a T; 89]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 90]

type AsMut = [&'a mut T; 90]

type AsRef = [&'a T; 90]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 91]

type AsMut = [&'a mut T; 91]

type AsRef = [&'a T; 91]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 92]

type AsMut = [&'a mut T; 92]

type AsRef = [&'a T; 92]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 93]

type AsMut = [&'a mut T; 93]

type AsRef = [&'a T; 93]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 94]

type AsMut = [&'a mut T; 94]

type AsRef = [&'a T; 94]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 95]

type AsMut = [&'a mut T; 95]

type AsRef = [&'a T; 95]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 96]

type AsMut = [&'a mut T; 96]

type AsRef = [&'a T; 96]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 97]

type AsMut = [&'a mut T; 97]

type AsRef = [&'a T; 97]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 98]

type AsMut = [&'a mut T; 98]

type AsRef = [&'a T; 98]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 99]

type AsMut = [&'a mut T; 99]

type AsRef = [&'a T; 99]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 100]

type AsMut = [&'a mut T; 100]

type AsRef = [&'a T; 100]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 101]

type AsMut = [&'a mut T; 101]

type AsRef = [&'a T; 101]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 102]

type AsMut = [&'a mut T; 102]

type AsRef = [&'a T; 102]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 103]

type AsMut = [&'a mut T; 103]

type AsRef = [&'a T; 103]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 104]

type AsMut = [&'a mut T; 104]

type AsRef = [&'a T; 104]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 105]

type AsMut = [&'a mut T; 105]

type AsRef = [&'a T; 105]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 106]

type AsMut = [&'a mut T; 106]

type AsRef = [&'a T; 106]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 107]

type AsMut = [&'a mut T; 107]

type AsRef = [&'a T; 107]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 108]

type AsMut = [&'a mut T; 108]

type AsRef = [&'a T; 108]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 109]

type AsMut = [&'a mut T; 109]

type AsRef = [&'a T; 109]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 110]

type AsMut = [&'a mut T; 110]

type AsRef = [&'a T; 110]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 111]

type AsMut = [&'a mut T; 111]

type AsRef = [&'a T; 111]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 112]

type AsMut = [&'a mut T; 112]

type AsRef = [&'a T; 112]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 113]

type AsMut = [&'a mut T; 113]

type AsRef = [&'a T; 113]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 114]

type AsMut = [&'a mut T; 114]

type AsRef = [&'a T; 114]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 115]

type AsMut = [&'a mut T; 115]

type AsRef = [&'a T; 115]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 116]

type AsMut = [&'a mut T; 116]

type AsRef = [&'a T; 116]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 117]

type AsMut = [&'a mut T; 117]

type AsRef = [&'a T; 117]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 118]

type AsMut = [&'a mut T; 118]

type AsRef = [&'a T; 118]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 119]

type AsMut = [&'a mut T; 119]

type AsRef = [&'a T; 119]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 120]

type AsMut = [&'a mut T; 120]

type AsRef = [&'a T; 120]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 121]

type AsMut = [&'a mut T; 121]

type AsRef = [&'a T; 121]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 122]

type AsMut = [&'a mut T; 122]

type AsRef = [&'a T; 122]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 123]

type AsMut = [&'a mut T; 123]

type AsRef = [&'a T; 123]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 124]

type AsMut = [&'a mut T; 124]

type AsRef = [&'a T; 124]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 125]

type AsMut = [&'a mut T; 125]

type AsRef = [&'a T; 125]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 126]

type AsMut = [&'a mut T; 126]

type AsRef = [&'a T; 126]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 127]

type AsMut = [&'a mut T; 127]

type AsRef = [&'a T; 127]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 128]

type AsMut = [&'a mut T; 128]

type AsRef = [&'a T; 128]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 200]

type AsMut = [&'a mut T; 200]

type AsRef = [&'a T; 200]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 256]

type AsMut = [&'a mut T; 256]

type AsRef = [&'a T; 256]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 300]

type AsMut = [&'a mut T; 300]

type AsRef = [&'a T; 300]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 400]

type AsMut = [&'a mut T; 400]

type AsRef = [&'a T; 400]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 500]

type AsMut = [&'a mut T; 500]

type AsRef = [&'a T; 500]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 512]

type AsMut = [&'a mut T; 512]

type AsRef = [&'a T; 512]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 600]

type AsMut = [&'a mut T; 600]

type AsRef = [&'a T; 600]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 700]

type AsMut = [&'a mut T; 700]

type AsRef = [&'a T; 700]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 800]

type AsMut = [&'a mut T; 800]

type AsRef = [&'a T; 800]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 900]

type AsMut = [&'a mut T; 900]

type AsRef = [&'a T; 900]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 1000]

type AsMut = [&'a mut T; 1000]

type AsRef = [&'a T; 1000]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 1024]

type AsMut = [&'a mut T; 1024]

type AsRef = [&'a T; 1024]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 2048]

type AsMut = [&'a mut T; 2048]

type AsRef = [&'a T; 2048]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 4096]

type AsMut = [&'a mut T; 4096]

type AsRef = [&'a T; 4096]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 8192]

type AsMut = [&'a mut T; 8192]

type AsRef = [&'a T; 8192]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 16384]

type AsMut = [&'a mut T; 16384]

type AsRef = [&'a T; 16384]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 32768]

type AsMut = [&'a mut T; 32768]

type AsRef = [&'a T; 32768]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

impl<'a, T: 'a> ArrayAsRef<'a> for [T; 65536]

type AsMut = [&'a mut T; 65536]

type AsRef = [&'a T; 65536]

fn as_ref_array(&'a self) -> Self::AsRef

fn as_mut_array(&'a mut self) -> Self::AsMut

Loading content...