Type Alias script::dom::bindings::utils::ProtoOrIfaceArray

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

1.55.0 · source

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]);

pub fn try_map<F, R>( self, f: F ) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryTypewhere F: FnMut(T) -> R, R: Try, <R as Try>::Residual: Residual<[<R as Try>::Output; N]>,

🔬This is a nightly-only experimental API. (array_try_map)

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));

1.57.0 (const: 1.57.0) · source

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

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

1.57.0 · source

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

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

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

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

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]);

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)]

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);

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

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

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]);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

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, &[]);
}

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

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]);

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

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]);
}

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

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]);

Trait Implementations§

The type of the items in the thing.

const CAPACITY: usize = 1_024usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 1024]

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

The type of the items in the thing.

const CAPACITY: usize = 13usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 13]

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

The type of the items in the thing.

const CAPACITY: usize = 17usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 17]

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

The type of the items in the thing.

const CAPACITY: usize = 20usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 20]

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

The type of the items in the thing.

const CAPACITY: usize = 23usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 23]

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

The type of the items in the thing.

const CAPACITY: usize = 26usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 26]

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

The type of the items in the thing.

const CAPACITY: usize = 3usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 3]

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

The type of the items in the thing.

const CAPACITY: usize = 33usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 33]

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

The type of the items in the thing.

const CAPACITY: usize = 512usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 512]

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

The type of the items in the thing.

const CAPACITY: usize = 8usize

The number of slots in the thing.

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

Gives a shared slice over the whole thing. Read more

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

Gives a unique slice over the whole thing. Read more

fn default() -> [T; 8]

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

type Item = T

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

fn as_bytes(&self) -> &[u8] ⓘ

Gets the bytes of this value. Read more

fn write_to(&self, bytes: &mut [u8]) -> Option<()>

Writes a copy of self to bytes. Read more

fn write_to_prefix(&self, bytes: &mut [u8]) -> Option<()>

Writes a copy of self to the prefix of bytes. Read more

Converts from Self to Self::ULE. Read more

Overwrites self with zeroes. Read more

fn new_zeroed() -> Selfwhere Self: Sized,

Creates an instance of Self from zeroed bytes. Read more

1.0.0 · source§

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::collections::hash_map::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));

fn hash<H>(&self, state: &mut H)where H: Hasher,

Feeds this value into the given Hasher. Read more

1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

1.50.0 · source§

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

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

The returned type after indexing.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, N>

Which kind of iterator are we turning this into?

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

type Item = T

The type of item that the parallel iterator will produce.

type Iter = IntoIter<T, N>

The parallel iterator type that will be created.

fn into_par_iter(self) -> <[T; N] as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more

1.0.0 · source§

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

Implements comparison of arrays lexicographically.

fn cmp(&self, other: &[T; N]) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0 · source§

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

fn le(&self, other: &[T; N]) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

fn ge(&self, other: &[T; N]) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

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

The element type of the slice being matched on.

fn as_slice(&self) -> &[<[T; N] as SlicePattern>::Item]

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

Currently, the consumers of SlicePattern need a slice.

impl<T, const COUNT: usize> Traceable for [T; COUNT]where T: Traceable,

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.

1.34.0 · source§

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));

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.

1.59.0 · source§

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));

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &mut [T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.

impl<T, const N: usize> TryFrom<ThinVec<T>> for [T; N]

fn try_from(vec: ThinVec<T>) -> Result<[T; N], ThinVec<T>>

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

Examples

use thin_vec::{ThinVec, thin_vec};
use std::convert::TryInto;

assert_eq!(thin_vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
assert_eq!(<ThinVec<i32>>::new().try_into(), Ok([]));

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

use thin_vec::{ThinVec, thin_vec};
use std::convert::TryInto;

let r: Result<[i32; 4], _> = (0..10).collect::<ThinVec<_>>().try_into();
assert_eq!(r, Err(thin_vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));

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

use thin_vec::{ThinVec, thin_vec};
use std::convert::TryInto;

let mut v = ThinVec::from("hello world");
v.sort();
v.truncate(2);
let [a, b]: [_; 2] = v.try_into().unwrap();
assert_eq!(a, b' ');
assert_eq!(b, b'd');

type Error = ThinVec<T>

The type returned in the event of a conversion error.

1.48.0 · source§

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

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([]));

If 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]));

If 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');

type Error = Vec<T, A>

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,

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([]));

If 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]));

If 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');

type Error = Vec<T, A>

The type returned in the event of a conversion error.

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

fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError>

Validates a byte slice, &[u8]. Read more

fn parse_byte_slice(bytes: &[u8]) -> Result<&[Self], ZeroVecError>

Parses a byte slice, &[u8], and return it as &[Self] with the same lifetime. Read more

unsafe fn from_byte_slice_unchecked(bytes: &[u8]) -> &[Self]

Takes a byte slice, &[u8], and return it as &[Self] with the same lifetime, assuming that this byte slice has previously been run through Self::parse_byte_slice() with success. Read more

fn as_byte_slice(slice: &[Self]) -> &[u8] ⓘ

Given &[Self], returns a &[u8] with the same lifetime. Read more

The type produced by Container::replace() and Container::remove(), also used during deserialization. If Self is human readable serialized, deserializing to Self::OwnedType should produce the same value once passed through Self::owned_as_self() Read more