Struct ArrayWrapper

pub struct ArrayWrapper<A> { /* private fields */ }

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 {}

• 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 :(

---

1. differences: ↩

2. See Sizes Limitations paragraph in crate docs. ↩

Implementations

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.

const SIZE: usize = A::SIZE

Size of the array.

type Item = <A as Array>::Item

Type of the Items in the array. i.e.

type Maybe = ArrayWrapper<<A as Array>::Maybe>

Same array but item is wrapped with MaybeUninit<_>.

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

Available on crate feature alloc only.

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

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 try_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 from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Self::Item>,

Creates an array from an iterator.

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.

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

where A: Array,

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

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

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

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

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

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

where A: Array,

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

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

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

fn as_ref(&self) -> &A

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

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 duplicate of the value.

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

Performs copy-assignment from source.

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> 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, Self: Sized,

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 as SliceIndex<[<A as Array>::Item]>>::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<ArrayWrapper<A>>

Which kind of iterator are we turning this into?

type Item = <A as Array>::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.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, T> PartialEq<[T]> for ArrayWrapper<A>

where A::Item: PartialEq<T>, A: Array,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'t, A, T> PartialEq<ArrayWrapper<A>> for &'t [T]

where T: PartialEq<A::Item>, A: Array,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, T> PartialEq<ArrayWrapper<A>> for [T]

where T: PartialEq<A::Item>, A: Array,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, B> PartialEq<B> for ArrayWrapper<A>

where A::Item: PartialEq<B::Item>, A: Array, B: Array,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

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

where A: Array,

Alias for ArrayExt::try_ref_cast

Examples

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 = &'a [<A as Array>::Item]

The type returned in the event of a conversion error.

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

Performs the conversion.

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 mut [<A as Array>::Item]> for &'a mut ArrayWrapper<A>

where A: Array,

Alias for ArrayExt::try_mut_cast

Examples

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 = &'a mut [<A as Array>::Item]

The type returned in the event of a conversion error.

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

Performs the conversion.

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

impl<A> Eq for ArrayWrapper<A>

where A: Array, A::Item: Eq,