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:
- A list with each element, i.e.,
[x, y, z]. - A repeat expression
[x; N], which produces an array withNcopies ofx. The type ofxmust beCopy.
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:
CopyCloneDebugIntoIterator(implemented for&[T; N]and&mut [T; N])PartialEq,PartialOrd,Eq,OrdHashAsRef,AsMutBorrow,BorrowMut
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 satisfiedRun
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]
F: FnMut(T) -> U,
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]
‘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]ⓘ[src]
Returns a slice containing the entire array. Equivalent to &s[..].
pub fn as_mut_slice(&mut self) -> &mut [T]ⓘ[src]
Returns a mutable slice containing the entire array. Equivalent to
&mut s[..].
pub fn each_ref(&self) -> [&T; N][src]
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 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]
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]
pub fn borrow_mut(&mut self) -> &mut [T]ⓘ[src]
impl<T, const N: usize> Debug for [T; N] where
T: Debug, [src]
T: Debug,
impl<T> Default for [T; 3] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 25] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 6] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 15] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 0]1.4.0[src]
impl<T> Default for [T; 30] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 23] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 9] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 32] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 20] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 11] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 2] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 8] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 28] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 21] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 16] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 10] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 4] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 14] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 7] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 26] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 27] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 29] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 31] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 18] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 24] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 12] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 19] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 1] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 13] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 22] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 5] where
T: Default, 1.4.0[src]
T: Default,
impl<T> Default for [T; 17] where
T: Default, 1.4.0[src]
T: Default,
impl<T, const N: usize> Eq for [T; N] where
T: Eq, [src]
T: Eq,
impl<T, const N: usize> Hash for [T; N] where
T: Hash, [src]
T: Hash,
pub fn hash<H>(&self, state: &mut H) where
H: Hasher, [src]
H: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]
H: Hasher,
impl<T, I, const N: usize> Index<I> for [T; N] where
[T]: Index<I>, 1.50.0[src]
[T]: Index<I>,
type Output = <[T] as Index<I>>::Output
The returned type after indexing.
pub fn index(&self, index: I) -> &<[T; N] as Index<I>>::Output[src]
impl<T, I, const N: usize> IndexMut<I> for [T; N] where
[T]: IndexMut<I>, 1.50.0[src]
[T]: IndexMut<I>,
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?
pub fn into_iter(self) -> Iter<'a, T>ⓘ[src]
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?
pub fn into_iter(self) -> IterMut<'a, T>ⓘ[src]
impl<T, const N: usize> Ord for [T; N] where
T: Ord, [src]
T: Ord,
Implements comparison of arrays lexicographically.
pub fn cmp(&self, other: &[T; N]) -> Ordering[src]
#[must_use]pub fn max(self, other: Self) -> Self1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self1.50.0[src]
impl<'_, A, B, const N: usize> PartialEq<&'_ [B]> for [A; N] where
A: PartialEq<B>, [src]
A: PartialEq<B>,
impl<'_, A, B, const N: usize> PartialEq<&'_ mut [B]> for [A; N] where
A: PartialEq<B>, [src]
A: PartialEq<B>,
impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N] where
A: PartialEq<B>, [src]
A: PartialEq<B>,
impl<A, B, const N: usize> PartialEq<[B]> for [A; N] where
A: PartialEq<B>, [src]
A: PartialEq<B>,
impl<T, const N: usize> PartialOrd<[T; N]> for [T; N] where
T: PartialOrd<T>, [src]
T: PartialOrd<T>,
pub fn partial_cmp(&self, other: &[T; N]) -> Option<Ordering>[src]
pub fn lt(&self, other: &[T; N]) -> bool[src]
pub fn le(&self, other: &[T; N]) -> bool[src]
pub fn ge(&self, other: &[T; N]) -> bool[src]
pub fn gt(&self, other: &[T; N]) -> bool[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.
pub fn as_slice(&self) -> &[<[T; N] as SlicePattern>::Item]ⓘ[src]
impl<'_, T, const N: usize> TryFrom<&'_ [T]> for [T; N] where
T: Copy, 1.34.0[src]
T: Copy,
type Error = TryFromSliceError
The type returned in the event of a conversion error.
pub fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError>[src]
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.
pub fn try_from(slice: &[T]) -> Result<&[T; N], TryFromSliceError>[src]
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.
pub fn try_from(slice: &mut [T]) -> Result<&mut [T; N], TryFromSliceError>[src]
impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N] where
A: Allocator, 1.48.0[src]
A: Allocator,
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,
T: RefUnwindSafe,
impl<T, const N: usize> Send for [T; N] where
T: Send,
T: Send,
impl<T, const N: usize> Sync for [T; N] where
T: Sync,
T: Sync,
impl<T, const N: usize> Unpin for [T; N] where
T: Unpin,
T: Unpin,
impl<T, const N: usize> UnwindSafe for [T; N] where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
pub fn borrow(&self) -> &TⓘNotable traits for &'_ mut I
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for &mut Rimpl<W: Write + ?Sized> Write for &mut W[src]
Notable traits for &'_ mut I
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for &mut Rimpl<W: Write + ?Sized> Write for &mut Wimpl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut I
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for &mut Rimpl<W: Write + ?Sized> Write for &mut W[src]
Notable traits for &'_ mut I
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for &mut Rimpl<W: Write + ?Sized> Write for &mut Wimpl<T, A> FixedSizeArray<T> for A where
A: Unsize<[T]>, [src]
A: Unsize<[T]>,
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone, [src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T[src]
pub fn clone_into(&self, target: &mut T)[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,