Primitive Type array1.0.0[]

A fixed-size array, denoted [T; N], for the element type, T, and the non-negative compile-time constant size, N.

There are two syntactic forms for creating an array:

Note that [expr; 0] is allowed, and produces an empty array. This will still evaluate expr, however, and immediately drop the resulting value, so be mindful of side effects.

Arrays of any size implement the following traits if the element type allows it:

Arrays of sizes from 0 to 32 (inclusive) implement the Default trait if the element type allows it. As a stopgap, trait implementations are statically generated up to size 32.

Arrays coerce to slices ([T]), so a slice method may be called on an array. Indeed, this provides most of the API for working with arrays. Slices have a dynamic size and do not coerce to arrays.

You can move elements out of an array with a slice pattern. If you want one element, see mem::replace.

Examples

let mut array: [i32; 3] = [0; 3];

array[1] = 1;
array[2] = 2;

assert_eq!([1, 2], &array[1..]);

// This loop prints: 0 1 2
for x in &array {
    print!("{} ", x);
}
Run

An array itself is not iterable:

let array: [i32; 3] = [0; 3];

for x in array { }
// error: the trait bound `[i32; 3]: std::iter::Iterator` is not satisfied
Run

The solution is to coerce the array to a slice by calling a slice method:

for x in array.iter() { }
Run

You can also use the array reference's IntoIterator implementation:

for x in &array { }
Run

You can use a slice pattern to move elements out of an array:

fn move_away(_: String) { /* Do interesting things. */ }

let [john, roa] = ["John".to_string(), "Roa".to_string()];
move_away(john);
move_away(roa);
Run

Implementations

impl<T, const N: usize> [T; N][src]

pub fn map<F, U>(self, f: F) -> [U; N] where
    F: FnMut(T) -> U, 
[src]

🔬 This is a nightly-only experimental API. (array_map #75243)

Returns an array of the same size as self, with function f applied to each element in order.

Examples

#![feature(array_map)]
let x = [1, 2, 3];
let y = x.map(|v| v + 1);
assert_eq!(y, [2, 3, 4]);

let x = [1, 2, 3];
let mut temp = 0;
let y = x.map(|v| { temp += 1; v * temp });
assert_eq!(y, [1, 4, 9]);

let x = ["Ferris", "Bueller's", "Day", "Off"];
let y = x.map(|v| v.len());
assert_eq!(y, [6, 9, 3, 3]);
Run

pub fn zip<U>(self, rhs: [U; N]) -> [(T, U); N][src]

🔬 This is a nightly-only experimental API. (array_zip #80094)

'Zips up' two arrays into a single array of pairs.

zip() returns a new array where every element is a tuple where the first element comes from the first array, and the second element comes from the second array. In other words, it zips two arrays together, into a single one.

Examples

#![feature(array_zip)]
let x = [1, 2, 3];
let y = [4, 5, 6];
let z = x.zip(y);
assert_eq!(z, [(1, 4), (2, 5), (3, 6)]);
Run

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

Notable traits for &[u8]

impl Read for &[u8]impl Write for &mut [u8]
[src]

🔬 This is a nightly-only experimental API. (array_methods #76118)

Returns a slice containing the entire array. Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [T]

Notable traits for &[u8]

impl Read for &[u8]impl Write for &mut [u8]
[src]

🔬 This is a nightly-only experimental API. (array_methods #76118)

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

pub fn each_ref(&self) -> [&T; N][src]

🔬 This is a nightly-only experimental API. (array_methods #76118)

Borrows each element and returns an array of references with the same size as self.

Example

#![feature(array_methods)]

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);
Run

This method is particularly useful if combined with other methods, like map. This way, you can can avoid moving the original array if its elements are not Copy.

#![feature(array_methods, array_map)]

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);
Run

pub fn each_mut(&mut self) -> [&mut T; N][src]

🔬 This is a nightly-only experimental API. (array_methods #76118)

Borrows each element mutably and returns an array of mutable references with the same size as self.

Example

#![feature(array_methods)]

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);
Run

Trait Implementations

impl<T, const N: usize> AsMut<[T]> for [T; N][src]

impl<T, const N: usize> AsRef<[T]> for [T; N][src]

impl<T, const N: usize> Borrow<[T]> for [T; N]1.4.0[src]

impl<T, const N: usize> BorrowMut<[T]> for [T; N]1.4.0[src]

impl<T, const N: usize> Debug for [T; N] where
    T: Debug
[src]

impl<T> Default for [T; 20] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 28] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 8] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 19] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 24] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 23] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 16] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 25] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 14] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 18] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 10] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 2] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 12] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 7] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 0]1.4.0[src]

impl<T> Default for [T; 15] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 6] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 3] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 17] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 32] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 21] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 26] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 1] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 13] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 4] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 27] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 9] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 30] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 22] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 31] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 29] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 11] where
    T: Default
1.4.0[src]

impl<T> Default for [T; 5] where
    T: Default
1.4.0[src]

impl<T, const N: usize> Eq for [T; N] where
    T: Eq
[src]

impl<T, const N: usize> Hash for [T; N] where
    T: Hash
[src]

impl<T, I, const N: usize> Index<I> for [T; N] where
    [T]: Index<I>, 
1.50.0[src]

type Output = <[T] as Index<I>>::Output

The returned type after indexing.

impl<T, I, const N: usize> IndexMut<I> for [T; N] where
    [T]: IndexMut<I>, 
1.50.0[src]

impl<'a, T, const N: usize> IntoIterator for &'a [T; N][src]

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N][src]

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

impl<T, const N: usize> Ord for [T; N] where
    T: Ord
[src]

Implements comparison of arrays lexicographically.

impl<'_, A, B, const N: usize> PartialEq<&'_ [B]> for [A; N] where
    A: PartialEq<B>, 
[src]

impl<'_, A, B, const N: usize> PartialEq<&'_ mut [B]> for [A; N] where
    A: PartialEq<B>, 
[src]

impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N] where
    A: PartialEq<B>, 
[src]

impl<A, B, const N: usize> PartialEq<[B]> for [A; N] where
    A: PartialEq<B>, 
[src]

impl<T, const N: usize> PartialOrd<[T; N]> for [T; N] where
    T: PartialOrd<T>, 
[src]

impl<T, const N: usize> SlicePattern for [T; N]1.51.0[src]

type Item = T

🔬 This is a nightly-only experimental API. (slice_pattern #56345)

stopgap trait for slice patterns

The element type of the slice being matched on.

impl<'_, T, const N: usize> TryFrom<&'_ [T]> for [T; N] where
    T: Copy
1.34.0[src]

type Error = TryFromSliceError

The type returned in the event of a conversion error.

impl<'a, T, const N: usize> TryFrom<&'a [T]> for &'a [T; N]1.34.0[src]

type Error = TryFromSliceError

The type returned in the event of a conversion error.

impl<'a, T, const N: usize> TryFrom<&'a mut [T]> for &'a mut [T; N]1.34.0[src]

type Error = TryFromSliceError

The type returned in the event of a conversion error.

impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N] where
    A: Allocator
1.48.0[src]

type Error = Vec<T, A>

The type returned in the event of a conversion error.

pub fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>[src]

Gets the entire contents of the Vec<T> as an array, if its size exactly matches that of the requested array.

Examples

use std::convert::TryInto;
assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));
Run

If the length doesn't match, the input comes back in Err:

use std::convert::TryInto;
let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
Run

If you're fine with just getting a prefix of the Vec<T>, you can call .truncate(N) first.

use std::convert::TryInto;
let mut v = String::from("hello world").into_bytes();
v.sort();
v.truncate(2);
let [a, b]: [_; 2] = v.try_into().unwrap();
assert_eq!(a, b' ');
assert_eq!(b, b'd');
Run

Auto Trait Implementations

impl<T, const N: usize> RefUnwindSafe for [T; N] where
    T: RefUnwindSafe
[src]

impl<T, const N: usize> Send for [T; N] where
    T: Send
[src]

impl<T, const N: usize> Sync for [T; N] where
    T: Sync
[src]

impl<T, const N: usize> Unpin for [T; N] where
    T: Unpin
[src]

impl<T, const N: usize> UnwindSafe for [T; N] where
    T: UnwindSafe
[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T, A> FixedSizeArray<T> for A where
    A: Unsize<[T]>, 
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.