Primitive Type array
1.0.0 ·Expand description
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
[expr; N]
whereN
is how many times to repeatexpr
in the array.expr
must either be:- A value of a type implementing the
Copy
trait - A
const
value
- A value of a type implementing the
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:
Copy
Clone
Debug
IntoIterator
(implemented for[T; N]
,&[T; N]
and&mut [T; N]
)PartialEq
,PartialOrd
,Eq
,Ord
Hash
AsRef
,AsMut
Borrow
,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 of sizes from 1 to 12 (inclusive) implement From<Tuple>
, where Tuple
is a homogeneous tuple of appropriate length.
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. Instead, use
slice.try_into().unwrap()
or <ArrayType>::try_from(slice).unwrap()
.
Array’s try_from(slice)
implementations (and the corresponding slice.try_into()
array implementations) succeed if the input slice length is the same as the result
array length. They optimize especially well when the optimizer can easily determine
the slice length, e.g. <[u8; 4]>::try_from(&slice[4..8]).unwrap()
. Array implements
TryFrom returning:
[T; N]
copies from the slice’s elements&[T; N]
references the original slice’s elements&mut [T; N]
references the original slice’s elements
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} ");
}
RunYou can also iterate over reference to the array’s elements:
let array: [i32; 3] = [0; 3];
for x in &array { }
RunYou can use <ArrayType>::try_from(slice)
or slice.try_into()
to get an array from
a slice:
let bytes: [u8; 3] = [1, 0, 2];
assert_eq!(1, u16::from_le_bytes(<[u8; 2]>::try_from(&bytes[0..2]).unwrap()));
assert_eq!(512, u16::from_le_bytes(bytes[1..3].try_into().unwrap()));
RunYou 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);
RunArrays can be created from homogeneous tuples of appropriate length:
let tuple: (u32, u32, u32) = (1, 2, 3);
let array: [u32; 3] = tuple.into();
Run§Editions
Prior to Rust 1.53, arrays did not implement IntoIterator
by value, so the method call
array.into_iter()
auto-referenced into a slice iterator. Right now, the old
behavior is preserved in the 2015 and 2018 editions of Rust for compatibility, ignoring
IntoIterator
by value. In the future, the behavior on the 2015 and 2018 edition
might be made consistent to the behavior of later editions.
// Rust 2015 and 2018:
let array: [i32; 3] = [0; 3];
// This creates a slice iterator, producing references to each value.
for item in array.into_iter().enumerate() {
let (i, x): (usize, &i32) = item;
println!("array[{i}] = {x}");
}
// The `array_into_iter` lint suggests this change for future compatibility:
for item in array.iter().enumerate() {
let (i, x): (usize, &i32) = item;
println!("array[{i}] = {x}");
}
// You can explicitly iterate an array by value using `IntoIterator::into_iter`
for item in IntoIterator::into_iter(array).enumerate() {
let (i, x): (usize, i32) = item;
println!("array[{i}] = {x}");
}
RunStarting in the 2021 edition, array.into_iter()
uses IntoIterator
normally to iterate
by value, and iter()
should be used to iterate by reference like previous editions.
// Rust 2021:
let array: [i32; 3] = [0; 3];
// This iterates by reference:
for item in array.iter().enumerate() {
let (i, x): (usize, &i32) = item;
println!("array[{i}] = {x}");
}
// This iterates by value:
for item in array.into_iter().enumerate() {
let (i, x): (usize, i32) = item;
println!("array[{i}] = {x}");
}
RunFuture language versions might start treating the array.into_iter()
syntax on editions 2015 and 2018 the same as on edition 2021. So code using
those older editions should still be written with this change in mind, to
prevent breakage in the future. The safest way to accomplish this is to
avoid the into_iter
syntax on those editions. If an edition update is not
viable/desired, there are multiple alternatives:
- use
iter
, equivalent to the old behavior, creating references - use
IntoIterator::into_iter
, equivalent to the post-2021 behavior (Rust 1.53+) - replace
for ... in array.into_iter() {
withfor ... in array {
, equivalent to the post-2021 behavior (Rust 1.53+)
// Rust 2015 and 2018:
let array: [i32; 3] = [0; 3];
// This iterates by reference:
for item in array.iter() {
let x: &i32 = item;
println!("{x}");
}
// This iterates by value:
for item in IntoIterator::into_iter(array) {
let x: i32 = item;
println!("{x}");
}
// This iterates by value:
for item in array {
let x: i32 = item;
println!("{x}");
}
// IntoIter can also start a chain.
// This iterates by value:
for item in IntoIterator::into_iter(array).enumerate() {
let (i, x): (usize, i32) = item;
println!("array[{i}] = {x}");
}
RunImplementations§
source§impl<T, const N: usize> [T; N]
impl<T, const N: usize> [T; N]
1.55.0 · sourcepub fn map<F, U>(self, f: F) -> [U; N]where
F: FnMut(T) -> U,
pub fn map<F, U>(self, f: F) -> [U; N]where
F: FnMut(T) -> U,
Returns an array of the same size as self
, with function f
applied to each element
in order.
If you don’t necessarily need a new fixed-size array, consider using
Iterator::map
instead.
§Note on performance and stack usage
Unfortunately, usages of this method are currently not always optimized as well as they could be. This mainly concerns large arrays, as mapping over small arrays seem to be optimized just fine. Also note that in debug mode (i.e. without any optimizations), this method can use a lot of stack space (a few times the size of the array or more).
Therefore, in performance-critical code, try to avoid using this method
on large arrays or check the emitted code. Also try to avoid chained
maps (e.g. arr.map(...).map(...)
).
In many cases, you can instead use Iterator::map
by calling .iter()
or .into_iter()
on your array. [T; N]::map
is only necessary if you
really need a new array of the same size as the result. Rust’s lazy
iterators tend to get optimized very well.
§Examples
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]);
Runsourcepub fn try_map<F, R>(
self,
f: F
) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryType
🔬This is a nightly-only experimental API. (array_try_map
#79711)
pub fn try_map<F, R>( self, f: F ) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryType
array_try_map
#79711)A fallible function f
applied to each element on array self
in order to
return an array the same size as self
or the first error encountered.
The return type of this function depends on the return type of the closure.
If you return Result<T, E>
from the closure, you’ll get a Result<[T; N], E>
.
If you return Option<T>
from the closure, you’ll get an Option<[T; N]>
.
§Examples
#![feature(array_try_map)]
let a = ["1", "2", "3"];
let b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);
assert_eq!(b, [2, 3, 4]);
let a = ["1", "2a", "3"];
let b = a.try_map(|v| v.parse::<u32>());
assert!(b.is_err());
use std::num::NonZeroU32;
let z = [1, 2, 0, 3, 4];
assert_eq!(z.try_map(NonZeroU32::new), None);
let a = [1, 2, 3];
let b = a.try_map(NonZeroU32::new);
let c = b.map(|x| x.map(NonZeroU32::get));
assert_eq!(c, Some(a));
Run1.57.0 (const: 1.57.0) · sourcepub const fn as_slice(&self) -> &[T]
pub const fn as_slice(&self) -> &[T]
Returns a slice containing the entire array. Equivalent to &s[..]
.
1.57.0 · sourcepub fn as_mut_slice(&mut self) -> &mut [T]
pub fn as_mut_slice(&mut self) -> &mut [T]
Returns a mutable slice containing the entire array. Equivalent to
&mut s[..]
.
1.77.0 · sourcepub fn each_ref(&self) -> [&T; N]
pub fn each_ref(&self) -> [&T; N]
Borrows each element and returns an array of references with the same
size as self
.
§Example
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]);
RunThis 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
.
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);
Run1.77.0 · sourcepub fn each_mut(&mut self) -> [&mut T; N]
pub fn each_mut(&mut self) -> [&mut T; N]
Borrows each element mutably and returns an array of mutable references
with the same size as self
.
§Example
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]);
Runsourcepub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])
🔬This is a nightly-only experimental API. (split_array
#90091)
pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])
split_array
#90091)Divides one array reference into two at an index.
The first will contain all indices from [0, M)
(excluding
the index M
itself) and the second will contain all
indices from [M, N)
(excluding the index N
itself).
§Panics
Panics if M > N
.
§Examples
#![feature(split_array)]
let v = [1, 2, 3, 4, 5, 6];
{
let (left, right) = v.split_array_ref::<0>();
assert_eq!(left, &[]);
assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}
{
let (left, right) = v.split_array_ref::<2>();
assert_eq!(left, &[1, 2]);
assert_eq!(right, &[3, 4, 5, 6]);
}
{
let (left, right) = v.split_array_ref::<6>();
assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
assert_eq!(right, &[]);
}
Runsourcepub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])
🔬This is a nightly-only experimental API. (split_array
#90091)
pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])
split_array
#90091)Divides one mutable array reference into two at an index.
The first will contain all indices from [0, M)
(excluding
the index M
itself) and the second will contain all
indices from [M, N)
(excluding the index N
itself).
§Panics
Panics if M > N
.
§Examples
#![feature(split_array)]
let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);
Runsourcepub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])
🔬This is a nightly-only experimental API. (split_array
#90091)
pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])
split_array
#90091)Divides one array reference into two at an index from the end.
The first will contain all indices from [0, N - M)
(excluding
the index N - M
itself) and the second will contain all
indices from [N - M, N)
(excluding the index N
itself).
§Panics
Panics if M > N
.
§Examples
#![feature(split_array)]
let v = [1, 2, 3, 4, 5, 6];
{
let (left, right) = v.rsplit_array_ref::<0>();
assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
assert_eq!(right, &[]);
}
{
let (left, right) = v.rsplit_array_ref::<2>();
assert_eq!(left, &[1, 2, 3, 4]);
assert_eq!(right, &[5, 6]);
}
{
let (left, right) = v.rsplit_array_ref::<6>();
assert_eq!(left, &[]);
assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}
Runsourcepub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])
🔬This is a nightly-only experimental API. (split_array
#90091)
pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])
split_array
#90091)Divides one mutable array reference into two at an index from the end.
The first will contain all indices from [0, N - M)
(excluding
the index N - M
itself) and the second will contain all
indices from [N - M, N)
(excluding the index N
itself).
§Panics
Panics if M > N
.
§Examples
#![feature(split_array)]
let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, &mut [3, 0, 5, 6][..]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);
Runsource§impl<const N: usize> [u8; N]
impl<const N: usize> [u8; N]
sourcepub const fn as_ascii(&self) -> Option<&[AsciiChar; N]>
🔬This is a nightly-only experimental API. (ascii_char
#110998)
pub const fn as_ascii(&self) -> Option<&[AsciiChar; N]>
ascii_char
#110998)Converts this array of bytes into a array of ASCII characters,
or returns None
if any of the characters is non-ASCII.
§Examples
#![feature(ascii_char)]
#![feature(const_option)]
const HEX_DIGITS: [std::ascii::Char; 16] =
*b"0123456789abcdef".as_ascii().unwrap();
assert_eq!(HEX_DIGITS[1].as_str(), "1");
assert_eq!(HEX_DIGITS[10].as_str(), "a");
Runsourcepub const unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]
🔬This is a nightly-only experimental API. (ascii_char
#110998)
pub const unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]
ascii_char
#110998)Converts this array of bytes into a array of ASCII characters, without checking whether they’re valid.
§Safety
Every byte in the array must be in 0..=127
, or else this is UB.
source§impl<T, const N: usize> [MaybeUninit<T>; N]
impl<T, const N: usize> [MaybeUninit<T>; N]
sourcepub const fn transpose(self) -> MaybeUninit<[T; N]>
🔬This is a nightly-only experimental API. (maybe_uninit_uninit_array_transpose
#96097)
pub const fn transpose(self) -> MaybeUninit<[T; N]>
maybe_uninit_uninit_array_transpose
#96097)Trait Implementations§
1.4.0 · source§impl<T, const N: usize> BorrowMut<[T]> for [T; N]
impl<T, const N: usize> BorrowMut<[T]> for [T; N]
source§fn borrow_mut(&mut self) -> &mut [T]
fn borrow_mut(&mut self) -> &mut [T]
1.71.0 · source§impl<T> From<[T; 10]> for (T, T, T, T, T, T, T, T, T, T)
impl<T> From<[T; 10]> for (T, T, T, T, T, T, T, T, T, T)
source§fn from(array: [T; 10]) -> (T, T, T, T, T, T, T, T, T, T)
fn from(array: [T; 10]) -> (T, T, T, T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 11]> for (T, T, T, T, T, T, T, T, T, T, T)
impl<T> From<[T; 11]> for (T, T, T, T, T, T, T, T, T, T, T)
source§fn from(array: [T; 11]) -> (T, T, T, T, T, T, T, T, T, T, T)
fn from(array: [T; 11]) -> (T, T, T, T, T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 12]> for (T, T, T, T, T, T, T, T, T, T, T, T)
impl<T> From<[T; 12]> for (T, T, T, T, T, T, T, T, T, T, T, T)
source§fn from(array: [T; 12]) -> (T, T, T, T, T, T, T, T, T, T, T, T)
fn from(array: [T; 12]) -> (T, T, T, T, T, T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 4]> for (T, T, T, T)
impl<T> From<[T; 4]> for (T, T, T, T)
source§fn from(array: [T; 4]) -> (T, T, T, T)
fn from(array: [T; 4]) -> (T, T, T, T)
1.71.0 · source§impl<T> From<[T; 5]> for (T, T, T, T, T)
impl<T> From<[T; 5]> for (T, T, T, T, T)
source§fn from(array: [T; 5]) -> (T, T, T, T, T)
fn from(array: [T; 5]) -> (T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 6]> for (T, T, T, T, T, T)
impl<T> From<[T; 6]> for (T, T, T, T, T, T)
source§fn from(array: [T; 6]) -> (T, T, T, T, T, T)
fn from(array: [T; 6]) -> (T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 7]> for (T, T, T, T, T, T, T)
impl<T> From<[T; 7]> for (T, T, T, T, T, T, T)
source§fn from(array: [T; 7]) -> (T, T, T, T, T, T, T)
fn from(array: [T; 7]) -> (T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 8]> for (T, T, T, T, T, T, T, T)
impl<T> From<[T; 8]> for (T, T, T, T, T, T, T, T)
source§fn from(array: [T; 8]) -> (T, T, T, T, T, T, T, T)
fn from(array: [T; 8]) -> (T, T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 9]> for (T, T, T, T, T, T, T, T, T)
impl<T> From<[T; 9]> for (T, T, T, T, T, T, T, T, T)
source§fn from(array: [T; 9]) -> (T, T, T, T, T, T, T, T, T)
fn from(array: [T; 9]) -> (T, T, T, T, T, T, T, T, T)
1.17.0 · source§impl From<[u16; 8]> for IpAddr
impl From<[u16; 8]> for IpAddr
source§fn from(segments: [u16; 8]) -> IpAddr
fn from(segments: [u16; 8]) -> IpAddr
Creates an IpAddr::V6
from an eight element 16-bit array.
§Examples
use std::net::{IpAddr, Ipv6Addr};
let addr = IpAddr::from([
525u16, 524u16, 523u16, 522u16,
521u16, 520u16, 519u16, 518u16,
]);
assert_eq!(
IpAddr::V6(Ipv6Addr::new(
0x20d, 0x20c,
0x20b, 0x20a,
0x209, 0x208,
0x207, 0x206
)),
addr
);
Run1.17.0 · source§impl From<[u8; 16]> for IpAddr
impl From<[u8; 16]> for IpAddr
source§fn from(octets: [u8; 16]) -> IpAddr
fn from(octets: [u8; 16]) -> IpAddr
Creates an IpAddr::V6
from a sixteen element byte array.
§Examples
use std::net::{IpAddr, Ipv6Addr};
let addr = IpAddr::from([
25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
IpAddr::V6(Ipv6Addr::new(
0x1918, 0x1716,
0x1514, 0x1312,
0x1110, 0x0f0e,
0x0d0c, 0x0b0a
)),
addr
);
Run1.9.0 · source§impl From<[u8; 16]> for Ipv6Addr
impl From<[u8; 16]> for Ipv6Addr
source§fn from(octets: [u8; 16]) -> Ipv6Addr
fn from(octets: [u8; 16]) -> Ipv6Addr
Creates an Ipv6Addr
from a sixteen element byte array.
§Examples
use std::net::Ipv6Addr;
let addr = Ipv6Addr::from([
25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
Ipv6Addr::new(
0x1918, 0x1716,
0x1514, 0x1312,
0x1110, 0x0f0e,
0x0d0c, 0x0b0a
),
addr
);
Run1.71.0 · source§impl<T> From<(T, T, T, T)> for [T; 4]
impl<T> From<(T, T, T, T)> for [T; 4]
source§fn from(tuple: (T, T, T, T)) -> [T; 4]
fn from(tuple: (T, T, T, T)) -> [T; 4]
1.71.0 · source§impl<T> From<(T, T, T, T, T)> for [T; 5]
impl<T> From<(T, T, T, T, T)> for [T; 5]
source§fn from(tuple: (T, T, T, T, T)) -> [T; 5]
fn from(tuple: (T, T, T, T, T)) -> [T; 5]
1.71.0 · source§impl<T> From<(T, T, T, T, T, T)> for [T; 6]
impl<T> From<(T, T, T, T, T, T)> for [T; 6]
source§fn from(tuple: (T, T, T, T, T, T)) -> [T; 6]
fn from(tuple: (T, T, T, T, T, T)) -> [T; 6]
1.71.0 · source§impl<T> From<(T, T, T, T, T, T, T)> for [T; 7]
impl<T> From<(T, T, T, T, T, T, T)> for [T; 7]
source§fn from(tuple: (T, T, T, T, T, T, T)) -> [T; 7]
fn from(tuple: (T, T, T, T, T, T, T)) -> [T; 7]
1.71.0 · source§impl<T> From<(T, T, T, T, T, T, T, T)> for [T; 8]
impl<T> From<(T, T, T, T, T, T, T, T)> for [T; 8]
source§fn from(tuple: (T, T, T, T, T, T, T, T)) -> [T; 8]
fn from(tuple: (T, T, T, T, T, T, T, T)) -> [T; 8]
1.71.0 · source§impl<T> From<(T, T, T, T, T, T, T, T, T)> for [T; 9]
impl<T> From<(T, T, T, T, T, T, T, T, T)> for [T; 9]
source§fn from(tuple: (T, T, T, T, T, T, T, T, T)) -> [T; 9]
fn from(tuple: (T, T, T, T, T, T, T, T, T)) -> [T; 9]
1.71.0 · source§impl<T> From<(T, T, T, T, T, T, T, T, T, T)> for [T; 10]
impl<T> From<(T, T, T, T, T, T, T, T, T, T)> for [T; 10]
source§fn from(tuple: (T, T, T, T, T, T, T, T, T, T)) -> [T; 10]
fn from(tuple: (T, T, T, T, T, T, T, T, T, T)) -> [T; 10]
1.71.0 · source§impl<T> From<(T, T, T, T, T, T, T, T, T, T, T)> for [T; 11]
impl<T> From<(T, T, T, T, T, T, T, T, T, T, T)> for [T; 11]
source§fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T)) -> [T; 11]
fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T)) -> [T; 11]
1.71.0 · source§impl<T> From<(T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 12]
impl<T> From<(T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 12]
source§fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T, T)) -> [T; 12]
fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T, T)) -> [T; 12]
source§impl<T, const N: usize> Hash for [T; N]where
T: Hash,
impl<T, const N: usize> Hash for [T; N]where
T: Hash,
The hash of an array is the same as that of the corresponding slice,
as required by the Borrow
implementation.
use std::hash::BuildHasher;
let b = std::hash::RandomState::new();
let a: [u8; 3] = [0xa8, 0x3c, 0x09];
let s: &[u8] = &[0xa8, 0x3c, 0x09];
assert_eq!(b.hash_one(a), b.hash_one(s));
Runsource§impl<'a, T, const N: usize> IntoIterator for &'a [T; N]
impl<'a, T, const N: usize> IntoIterator for &'a [T; N]
source§impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N]
impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N]
1.53.0 · source§impl<T, const N: usize> IntoIterator for [T; N]
impl<T, const N: usize> IntoIterator for [T; N]
source§fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter
fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter
Creates a consuming iterator, that is, one that moves each value out of
the array (from start to end). The array cannot be used after calling
this unless T
implements Copy
, so the whole array is copied.
Arrays have special behavior when calling .into_iter()
prior to the
2021 edition – see the array Editions section for more information.
source§impl<T, const N: usize> Ord for [T; N]where
T: Ord,
impl<T, const N: usize> Ord for [T; N]where
T: Ord,
Implements comparison of arrays lexicographically.
source§impl<A, B, const N: usize> PartialEq<&mut [B]> for [A; N]where
A: PartialEq<B>,
impl<A, B, const N: usize> PartialEq<&mut [B]> for [A; N]where
A: PartialEq<B>,
source§impl<T, const N: usize> PartialOrd for [T; N]where
T: PartialOrd,
impl<T, const N: usize> PartialOrd for [T; N]where
T: PartialOrd,
source§fn le(&self, other: &[T; N]) -> bool
fn le(&self, other: &[T; N]) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b, const N: usize> Pattern<'a> for &'b [char; N]
impl<'a, 'b, const N: usize> Pattern<'a> for &'b [char; N]
Searches for chars that are equal to any of the char
s in the array.
§Examples
assert_eq!("Hello world".find(&['o', 'l']), Some(2));
assert_eq!("Hello world".find(&['h', 'w']), Some(6));
Run§type Searcher = CharArrayRefSearcher<'a, 'b, N>
type Searcher = CharArrayRefSearcher<'a, 'b, N>
pattern
#27721)source§fn into_searcher(self, haystack: &'a str) -> CharArrayRefSearcher<'a, 'b, N>
fn into_searcher(self, haystack: &'a str) -> CharArrayRefSearcher<'a, 'b, N>
pattern
#27721)self
and the haystack
to search in.source§fn is_contained_in(self, haystack: &'a str) -> bool
fn is_contained_in(self, haystack: &'a str) -> bool
pattern
#27721)source§fn is_prefix_of(self, haystack: &'a str) -> bool
fn is_prefix_of(self, haystack: &'a str) -> bool
pattern
#27721)source§fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
pattern
#27721)source§fn is_suffix_of(self, haystack: &'a str) -> boolwhere
CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,
fn is_suffix_of(self, haystack: &'a str) -> boolwhere
CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,
pattern
#27721)source§fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where
CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where
CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,
pattern
#27721)source§impl<'a, const N: usize> Pattern<'a> for [char; N]
impl<'a, const N: usize> Pattern<'a> for [char; N]
Searches for chars that are equal to any of the char
s in the array.
§Examples
assert_eq!("Hello world".find(['o', 'l']), Some(2));
assert_eq!("Hello world".find(['h', 'w']), Some(6));
Run§type Searcher = CharArraySearcher<'a, N>
type Searcher = CharArraySearcher<'a, N>
pattern
#27721)source§fn into_searcher(self, haystack: &'a str) -> CharArraySearcher<'a, N>
fn into_searcher(self, haystack: &'a str) -> CharArraySearcher<'a, N>
pattern
#27721)self
and the haystack
to search in.source§fn is_contained_in(self, haystack: &'a str) -> bool
fn is_contained_in(self, haystack: &'a str) -> bool
pattern
#27721)source§fn is_prefix_of(self, haystack: &'a str) -> bool
fn is_prefix_of(self, haystack: &'a str) -> bool
pattern
#27721)source§fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
pattern
#27721)source§fn is_suffix_of(self, haystack: &'a str) -> boolwhere
CharArraySearcher<'a, N>: ReverseSearcher<'a>,
fn is_suffix_of(self, haystack: &'a str) -> boolwhere
CharArraySearcher<'a, N>: ReverseSearcher<'a>,
pattern
#27721)source§fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where
CharArraySearcher<'a, N>: ReverseSearcher<'a>,
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where
CharArraySearcher<'a, N>: ReverseSearcher<'a>,
pattern
#27721)1.51.0 · source§impl<T, const N: usize> SlicePattern for [T; N]
impl<T, const N: usize> SlicePattern for [T; N]
1.34.0 · source§impl<'a, T, const N: usize> TryFrom<&'a [T]> for &'a [T; N]
impl<'a, T, const N: usize> TryFrom<&'a [T]> for &'a [T; N]
Tries to create an array ref &[T; N]
from a slice ref &[T]
. Succeeds if
slice.len() == N
.
let bytes: [u8; 3] = [1, 0, 2];
let bytes_head: &[u8; 2] = <&[u8; 2]>::try_from(&bytes[0..2]).unwrap();
assert_eq!(1, u16::from_le_bytes(*bytes_head));
let bytes_tail: &[u8; 2] = bytes[1..3].try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(*bytes_tail));
Run§type Error = TryFromSliceError
type Error = TryFromSliceError
1.34.0 · source§impl<T, const N: usize> TryFrom<&[T]> for [T; N]where
T: Copy,
impl<T, const N: usize> TryFrom<&[T]> for [T; N]where
T: Copy,
Tries to create an array [T; N]
by copying from a slice &[T]
. Succeeds if
slice.len() == N
.
let bytes: [u8; 3] = [1, 0, 2];
let bytes_head: [u8; 2] = <[u8; 2]>::try_from(&bytes[0..2]).unwrap();
assert_eq!(1, u16::from_le_bytes(bytes_head));
let bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(bytes_tail));
Run§type Error = TryFromSliceError
type Error = TryFromSliceError
1.34.0 · source§impl<'a, T, const N: usize> TryFrom<&'a mut [T]> for &'a mut [T; N]
impl<'a, T, const N: usize> TryFrom<&'a mut [T]> for &'a mut [T; N]
Tries to create a mutable array ref &mut [T; N]
from a mutable slice ref
&mut [T]
. Succeeds if slice.len() == N
.
let mut bytes: [u8; 3] = [1, 0, 2];
let bytes_head: &mut [u8; 2] = <&mut [u8; 2]>::try_from(&mut bytes[0..2]).unwrap();
assert_eq!(1, u16::from_le_bytes(*bytes_head));
let bytes_tail: &mut [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(*bytes_tail));
Run§type Error = TryFromSliceError
type Error = TryFromSliceError
1.59.0 · source§impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]where
T: Copy,
impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]where
T: Copy,
Tries to create an array [T; N]
by copying from a mutable slice &mut [T]
.
Succeeds if slice.len() == N
.
let mut bytes: [u8; 3] = [1, 0, 2];
let bytes_head: [u8; 2] = <[u8; 2]>::try_from(&mut bytes[0..2]).unwrap();
assert_eq!(1, u16::from_le_bytes(bytes_head));
let bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(bytes_tail));
Run§type Error = TryFromSliceError
type Error = TryFromSliceError
1.43.0 · source§impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]>
impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]>
source§fn try_from(
boxed_slice: Box<[T]>
) -> Result<Box<[T; N]>, <Box<[T; N]> as TryFrom<Box<[T]>>>::Error>
fn try_from( boxed_slice: Box<[T]> ) -> Result<Box<[T; N]>, <Box<[T; N]> as TryFrom<Box<[T]>>>::Error>
Attempts to convert a Box<[T]>
into a Box<[T; N]>
.
The conversion occurs in-place and does not require a new memory allocation.
§Errors
Returns the old Box<[T]>
in the Err
variant if
boxed_slice.len()
does not equal N
.
1.66.0 · source§impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>
impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>
source§fn try_from(
vec: Vec<T>
) -> Result<Box<[T; N]>, <Box<[T; N]> as TryFrom<Vec<T>>>::Error>
fn try_from( vec: Vec<T> ) -> Result<Box<[T; N]>, <Box<[T; N]> as TryFrom<Vec<T>>>::Error>
Attempts to convert a Vec<T>
into a Box<[T; N]>
.
Like Vec::into_boxed_slice
, this is in-place if vec.capacity() == N
,
but will require a reallocation otherwise.
§Errors
Returns the original Vec<T>
in the Err
variant if
boxed_slice.len()
does not equal N
.
§Examples
This can be used with vec!
to create an array on the heap:
let state: Box<[f32; 100]> = vec![1.0; 100].try_into().unwrap();
assert_eq!(state.len(), 100);
Run1.48.0 · source§impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]where
A: Allocator,
impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]where
A: Allocator,
source§fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
Gets the entire contents of the Vec<T>
as an array,
if its size exactly matches that of the requested array.
§Examples
assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));
RunIf the length doesn’t match, the input comes back in Err
:
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]));
RunIf you’re fine with just getting a prefix of the Vec<T>
,
you can call .truncate(N)
first.
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