Struct arraylib::ArrayWrapper

#[repr(transparent)]
pub struct ArrayWrapper<A> { /* fields omitted */ }

Wrapper over array types. It implements the same¹ traits as array, but not for only arrays of sizes 0..=32 but for all arrays, those sizes are supported by the crate²:

• Debug
• IntoIterator
• PartialEq, PartialOrd, Eq, Ord
• Hash
• AsRef, AsMut (both for A and [A::Item])
• Borrow, BorrowMut
• Index, IndexMut
• Default
• TryFrom

Note: Implementations of the most trai just copy-pasted from std

Examples

PartialEq/Eq :

use arraylib::{ArrayExt, ArrayWrapper};

let arr = [1, 2, 3].wrap();
assert_eq!(arr, [1, 2, 3]);
assert_eq!(format!("{:?}", arr), "[1, 2, 3]");
assert!(arr < [1, 4, 0]);
assert_eq!(arr[1], 2);

assert!(arr.into_iter().eq(vec![1, 2, 3].into_iter()));

assert_eq!(<ArrayWrapper<[i32; 3]> as Default>::default(), [0, 0, 0]);

use arraylib::{ArrayExt, ArrayWrapper};
use std::borrow::{Borrow, BorrowMut};

let mut arr = [1, 2, 3].wrap();

let slice: &[i32] = arr.as_ref();
assert_eq!(slice, &[1, 2, 3]);

use arraylib::ArrayExt;
use std::{
    collections::hash_map::DefaultHasher,
    hash::{Hash, Hasher},
};

let mut hasher = DefaultHasher::new();
[1, 2, 3].wrap().hash(&mut hasher);
let hash0 = hasher.finish();

let mut hasher = DefaultHasher::new();
[1, 2, 3].hash(&mut hasher);
let hash1 = hasher.finish();

assert_eq!(hash0, hash1);

In difference with std, ArrayWrapper is iterable:

use arraylib::ArrayExt;

let arr = [0, 3, 45, 91].wrap();
for x in arr {}

---

1. differences:

   • IntoIterator (on std's array IntoIterator is implemented only on &[T; N] and on &mut [T; N] while on ArrayWrapper it's implemented directly (using IterMove))
   • In some traits instead of TryFromSliceError there is SizeError
   • Copy/Clone are implemented only when A: Copy/Clone and not when A::Item: Copy/Clone because we can't use compiler magic :(
    ↩

2. See Sizes Limitations paragraph in crate docs. ↩

Methods

impl<A> ArrayWrapper<A> where
    A: Array, 

pub fn new(inner: A) -> Self

Create new ArrayWrapper

use arraylib::ArrayWrapper;

let arr = ArrayWrapper::new([0, 1, 2, 3]);
println!("{:?}", arr);

pub fn into_inner(self) -> A

Destruct ArrayWrapper into inner array

use arraylib::ArrayWrapper;

let arr = ArrayWrapper::new([0, 1, 2, 3]);
// ...
let arr = arr.into_inner();
println!("{:?}", arr);

Trait Implementations

impl<A> Array for ArrayWrapper<A> where
    A: Array, 

Safety

ArrayWrapper has #[repr(transparent)] so it has the same ABI as A. So if A is array then so is ArrayWrapper.

type Item = A::Item

Type of the Items in the array. i.e. # use arraylib::Array; fn dummy<T>() where [T; 4]: Array<Item = T> # {}

type Maybe = ArrayWrapper<A::Maybe>

Same array but item is wrapped with MaybeUninit<_>. # use arraylib::Array; fn dummy<T>() where [T; 4]: Array<Item = T, Maybe = [core::mem::MaybeUninit<T>; 4]> # {}

const SIZE: usize

Size of the array.

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

Extracts a slice containing the entire array.

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

Extracts a mutable slice of the entire array.

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

Create new array, filled with elements returned by f. If f return Err then this method also return Err.

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

Create new array, filled with elements returned by f

fn try_from_fn<F, E>(f: F) -> Result<Self, E> where
    F: FnMut(usize) -> Result<Self::Item, E>, 

Create new array, filled with elements returned by f. If f return Err then this method also return Err.

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

Create new array, filled with elements returned by f

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

Creates an array from an iterator.

fn into_uninit(self) -> Self::Maybe

Converts self into [MaybeUninit<Self::Item>; Self::Size]. This function is used internally in this crate for some unsafe code.

fn uninit() -> Self::Maybe

Creates uninitialized array of [MaybeUninit<T>].

unsafe fn assume_init(uninit: Self::Maybe) -> Self

Extracts the values from the [MaybeUninit<T>] containers.

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

Converts self into Box<[Self::Item]>

impl<A> AsMut<[<A as Array>::Item]> for ArrayWrapper<A> where
    A: Array, 

fn as_mut(&mut self) -> &mut [A::Item]

Performs the conversion.

impl<A> AsMut<A> for ArrayWrapper<A>

fn as_mut(&mut self) -> &mut A

Performs the conversion.

impl<A> AsRef<[<A as Array>::Item]> for ArrayWrapper<A> where
    A: Array, 

fn as_ref(&self) -> &[A::Item]

Performs the conversion.

impl<A> AsRef<A> for ArrayWrapper<A>

fn as_ref(&self) -> &A

Performs the conversion.

impl<A> Borrow<[<A as Array>::Item]> for ArrayWrapper<A> where
    A: Array, 

fn borrow(&self) -> &[A::Item]

Immutably borrows from an owned value.

impl<A> BorrowMut<[<A as Array>::Item]> for ArrayWrapper<A> where
    A: Array, 

fn borrow_mut(&mut self) -> &mut [A::Item]

Mutably borrows from an owned value.

impl<A: Clone> Clone for ArrayWrapper<A>

fn clone(&self) -> ArrayWrapper<A>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Copy> Copy for ArrayWrapper<A>

impl<A> Debug for ArrayWrapper<A> where
    A::Item: Debug,
    A: Array, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<A> Default for ArrayWrapper<A> where
    A: Array,
    A::Item: Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<A> Eq for ArrayWrapper<A> where
    A: Array,
    A::Item: Eq, 

impl<A> Hash for ArrayWrapper<A> where
    A::Item: Hash,
    A: Array, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<A, Idx> Index<Idx> for ArrayWrapper<A> where
    A: Array,
    Idx: SliceIndex<[A::Item]>, 

type Output = Idx::Output

The returned type after indexing.

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A, Idx> IndexMut<Idx> for ArrayWrapper<A> where
    A: Array,
    Idx: SliceIndex<[A::Item]>, 

fn index_mut(&mut self, index: Idx) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<A> IntoIterator for ArrayWrapper<A> where
    A: Array, 

type IntoIter = IterMove<Self>

Which kind of iterator are we turning this into?

type Item = A::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A> Ord for ArrayWrapper<A> where
    A: Array,
    A::Item: Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use] fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use] fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use] fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl<'t, A, T> PartialEq<&'t [T]> for ArrayWrapper<A> where
    A::Item: PartialEq<T>,
    A: Array, 

fn eq(&self, other: &&'t [T]) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'t, A, T> PartialEq<&'t mut [T]> for ArrayWrapper<A> where
    A::Item: PartialEq<T>,
    A: Array, 

fn eq(&self, other: &&'t mut [T]) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, T> PartialEq<[T]> for ArrayWrapper<A> where
    A::Item: PartialEq<T>,
    A: Array, 

fn eq(&self, other: &[T]) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, T> PartialEq<ArrayWrapper<A>> for [T] where
    T: PartialEq<A::Item>,
    A: Array, 

fn eq(&self, other: &ArrayWrapper<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'t, A, T> PartialEq<ArrayWrapper<A>> for &'t [T] where
    T: PartialEq<A::Item>,
    A: Array, 

fn eq(&self, other: &ArrayWrapper<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'t, A, T> PartialEq<ArrayWrapper<A>> for &'t mut [T] where
    T: PartialEq<A::Item>,
    A: Array, 

fn eq(&self, other: &ArrayWrapper<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, B> PartialEq<B> for ArrayWrapper<A> where
    A::Item: PartialEq<B::Item>,
    A: Array,
    B: Array, 

fn eq(&self, other: &B) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, B> PartialOrd<B> for ArrayWrapper<A> where
    A: Array,
    B: Array<Item = A::Item>,
    A::Item: PartialOrd, 

fn partial_cmp(&self, other: &B) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &B) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &B) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &B) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &B) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'_, A> TryFrom<&'_ [<A as Array>::Item]> for ArrayWrapper<A> where
    A::Item: Copy,
    A: Array, 

type Error = SizeError

The type returned in the event of a conversion error.

fn try_from(slice: &[A::Item]) -> Result<Self, SizeError>

Performs the conversion.

impl<'a, A> TryFrom<&'a [<A as Array>::Item]> for &'a ArrayWrapper<A> where
    A: Array, 

use arraylib::ArrayWrapper;
use core::convert::TryInto;

let slice = &[0, 1, 2][..];
let arr: &ArrayWrapper<[i32; 3]> = slice.try_into().unwrap();
assert_eq!(arr, &ArrayWrapper::new([0, 1, 2]))

type Error = SizeError

The type returned in the event of a conversion error.

fn try_from(slice: &'a [A::Item]) -> Result<Self, SizeError>

Performs the conversion.

impl<'a, A> TryFrom<&'a mut [<A as Array>::Item]> for &'a mut ArrayWrapper<A> where
    A: Array, 

use arraylib::ArrayWrapper;
use core::convert::TryInto;

let slice = &mut [0, 1, 2][..];
let arr: &mut ArrayWrapper<[i32; 3]> = slice.try_into().unwrap();
assert_eq!(arr, &ArrayWrapper::new([0, 1, 2]))

type Error = SizeError

The type returned in the event of a conversion error.

fn try_from(slice: &'a mut [A::Item]) -> Result<Self, SizeError>

Performs the conversion.