Trait ArrayAsRef

Source

pub trait ArrayAsRef<'a>: Arraywhere
    <Self as Array>::Item: 'a,{
    type AsRef: Array<Item = &'a <Self as Array>::Item>;
    type AsMut: Array<Item = &'a mut <Self as Array>::Item>;

    // Required methods
    fn as_ref_array(&'a self) -> Self::AsRef;
    fn as_mut_array(&'a mut self) -> Self::AsMut;
}

Expand description

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

Required Associated Types§

Source

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

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

Source

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

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

Required Methods§

Source

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.

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.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Trait ArrayAsRef Copy item path

Required Associated Types§

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

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

Required Methods§

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

§Examples

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

§Examples

Dyn Compatibility§

Implementations on Foreign Types§

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

Trait ArrayAsRef