Trait Array

pub trait Array {
    type Item: Default;

    const CAPACITY: usize;

    // Required methods
    fn as_slice(&self) -> &[Self::Item];
    fn as_slice_mut(&mut self) -> &mut [Self::Item];
    fn default() -> Self;
}

A trait for types that are an array.

An “array”, for our purposes, has the following properties:

• Owns some number of elements.
• The element type can be generic, but must implement Default.
• The capacity is fixed at compile time, based on the implementing type.
• You can get a shared or mutable slice to the elements.

You are generally not expected to need to implement this yourself. It is already implemented for all array lengths.

Additional lengths can easily be added upon request.

Safety Reminder

Just a reminder: this trait is 100% safe, which means that unsafe code must not rely on an instance of this trait being correct.

Required Associated Constants

const CAPACITY: usize

The number of slots in the thing.

Required Associated Types

type Item: Default

The type of the items in the thing.

Required Methods

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

Gives a shared slice over the whole thing.

A correct implementation will return a slice with a length equal to the CAPACITY value.

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

Gives a unique slice over the whole thing.

A correct implementation will return a slice with a length equal to the CAPACITY value.

fn default() -> Self

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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

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

const CAPACITY: usize = N

type Item = T

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

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

fn default() -> Self

Implementors