Returns an array of the same size as self, with function f applied to each element\nin order.
If you don’t necessarily need a new fixed-size array, consider using\nIterator::map instead.
Note that this method is eager. It evaluates f all N times before\nreturning the new array.
That means that arr.map(f).map(g) is, in general, not equivalent to\narray.map(|x| g(f(x))), as the former calls f 4 times then g 4 times,\nwhereas the latter interleaves the calls (fgfgfgfg).
A consequence of this is that it can have fairly-high stack usage, especially\nin debug mode or for long arrays. The backend may be able to optimize it\naway, but especially for complicated mappings it might not be able to.
\nIf you’re doing a one-step map and really want an array as the result,\nthen absolutely use this method. Its implementation uses a bunch of tricks\nto help the optimizer handle it well. Particularly for simple arrays,\nlike [u8; 3] or [f32; 4], there’s nothing to be concerned about.
However, if you don’t actually need an array of the results specifically,\njust to process them, then you likely want Iterator::map instead.
For example, rather than doing an array-to-array map of all the elements\nin the array up-front and only iterating after that completes,
\n\nfor x in my_array.map(f) {\n // ...\n}It’s often better to use an iterator along the lines of
\n\nfor x in my_array.into_iter().map(f) {\n // ...\n}as that’s more likely to avoid large temporaries.
\nlet x = [1, 2, 3];\nlet y = x.map(|v| v + 1);\nassert_eq!(y, [2, 3, 4]);\n\nlet x = [1, 2, 3];\nlet mut temp = 0;\nlet y = x.map(|v| { temp += 1; v * temp });\nassert_eq!(y, [1, 4, 9]);\n\nlet x = [\"Ferris\", \"Bueller's\", \"Day\", \"Off\"];\nlet y = x.map(|v| v.len());\nassert_eq!(y, [6, 9, 3, 3]);array_try_map)A fallible function f applied to each element on array self in order to\nreturn 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.\nIf you return Result<T, E> from the closure, you’ll get a Result<[T; N], E>.\nIf you return Option<T> from the closure, you’ll get an Option<[T; N]>.
#![feature(array_try_map)]\n\nlet a = [\"1\", \"2\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);\nassert_eq!(b, [2, 3, 4]);\n\nlet a = [\"1\", \"2a\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>());\nassert!(b.is_err());\n\nuse std::num::NonZero;\n\nlet z = [1, 2, 0, 3, 4];\nassert_eq!(z.try_map(NonZero::new), None);\n\nlet a = [1, 2, 3];\nlet b = a.try_map(NonZero::new);\nlet c = b.map(|x| x.map(NonZero::get));\nassert_eq!(c, Some(a));Returns a slice containing the entire array. Equivalent to &s[..].
Returns a mutable slice containing the entire array. Equivalent to\n&mut s[..].
Borrows each element and returns an array of references with the same\nsize as self.
let floats = [3.1, 2.7, -1.0];\nlet float_refs: [&f64; 3] = floats.each_ref();\nassert_eq!(float_refs, [&3.1, &2.7, &-1.0]);This method is particularly useful if combined with other methods, like\nmap. This way, you can avoid moving the original\narray if its elements are not Copy.
let strings = [\"Ferris\".to_string(), \"♥\".to_string(), \"Rust\".to_string()];\nlet is_ascii = strings.each_ref().map(|s| s.is_ascii());\nassert_eq!(is_ascii, [true, false, true]);\n\n// We can still access the original array: it has not been moved.\nassert_eq!(strings.len(), 3);Borrows each element mutably and returns an array of mutable references\nwith the same size as self.
\nlet mut floats = [3.1, 2.7, -1.0];\nlet float_refs: [&mut f64; 3] = floats.each_mut();\n*float_refs[0] = 0.0;\nassert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);\nassert_eq!(floats, [0.0, 2.7, -1.0]);split_array)Divides one array reference into two at an index.
\nThe first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).
Panics if M > N.
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n let (left, right) = v.split_array_ref::<0>();\n assert_eq!(left, &[]);\n assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}\n\n{\n let (left, right) = v.split_array_ref::<2>();\n assert_eq!(left, &[1, 2]);\n assert_eq!(right, &[3, 4, 5, 6]);\n}\n\n{\n let (left, right) = v.split_array_ref::<6>();\n assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n assert_eq!(right, &[]);\n}split_array)Divides one mutable array reference into two at an index.
\nThe first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).
Panics if M > N.
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.split_array_mut::<2>();\nassert_eq!(left, &mut [1, 0][..]);\nassert_eq!(right, &mut [3, 0, 5, 6]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);split_array)Divides one array reference into two at an index from the end.
\nThe first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).
Panics if M > N.
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n let (left, right) = v.rsplit_array_ref::<0>();\n assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n assert_eq!(right, &[]);\n}\n\n{\n let (left, right) = v.rsplit_array_ref::<2>();\n assert_eq!(left, &[1, 2, 3, 4]);\n assert_eq!(right, &[5, 6]);\n}\n\n{\n let (left, right) = v.rsplit_array_ref::<6>();\n assert_eq!(left, &[]);\n assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}split_array)Divides one mutable array reference into two at an index from the end.
\nThe first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).
Panics if M > N.
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.rsplit_array_mut::<4>();\nassert_eq!(left, &mut [1, 0]);\nassert_eq!(right, &mut [3, 0, 5, 6][..]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);const_generics only.fmt::Debug when an assert fails. Read morefmt::Debug when an assert fails. Read moreabs comparison, displayed when an assert fails.ulps comparison, displayed when an assert fails.fmt::Debug. Read moreabs_all comparison, displayed when an assert fails.ulps_all comparison, displayed when an assert fails.tarpaulin_include only.Note that overly-large arrays may cause the conversions to fail.
\nself in a BitArray.Reader].self into buf in the expected format for the database.self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the largest\nmagnitude. Read moreself is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the smallest\nmagnitude. Read moreself is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the first input. Read moreself is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the second input. Read moreSelf, with fields recursively wrapped\nby DebugUlpsDiff.relaxed_coherence only.&Self. Read morearray-impls only.Type in its binary format. Read moreType.tracker. Read moretracker. Read moreThe hash of an array is the same as that of the corresponding slice,\nas required by the Borrow implementation.
use std::hash::BuildHasher;\n\nlet b = std::hash::RandomState::new();\nlet a: [u8; 3] = [0xa8, 0x3c, 0x09];\nlet s: &[u8] = &[0xa8, 0x3c, 0x09];\nassert_eq!(b.hash_one(a), b.hash_one(s));Creates a consuming iterator, that is, one that moves each value out of\nthe array (from start to end).
\nThe array cannot be used after calling this unless T implements\nCopy, so the whole array is copied.
Arrays have special behavior when calling .into_iter() prior to the\n2021 edition – see the array Editions section for more information.
Self. Read moreVarULE] type for this data struct, or [()]\nif it cannot be represented as [VarULE].Implements comparison of arrays lexicographically.
\n","flow::engine::TableName"],[" Implements comparison of arrays lexicographically. Tries to create an array Tries to create an array Gets the entire contents of the If the length doesn’t match, the input comes back in If you’re fine with just getting a prefix of the Gets the entire contents of the If the length doesn’t match, the input comes back in If you’re fine with just getting a prefix of the Impl [ Impl [ Returns an array of the same size as If you don’t necessarily need a new fixed-size array, consider using\n Note that this method is eager. It evaluates That means that A consequence of this is that it can have fairly-high stack usage, especially\nin debug mode or for long arrays. The backend may be able to optimize it\naway, but especially for complicated mappings it might not be able to. If you’re doing a one-step However, if you don’t actually need an array of the results specifically,\njust to process them, then you likely want For example, rather than doing an array-to-array map of all the elements\nin the array up-front and only iterating after that completes, It’s often better to use an iterator along the lines of as that’s more likely to avoid large temporaries. A fallible function The return type of this function depends on the return type of the closure.\nIf you return Returns a slice containing the entire array. Equivalent to Returns a mutable slice containing the entire array. Equivalent to\n Borrows each element and returns an array of references with the same\nsize as This method is particularly useful if combined with other methods, like\n Borrows each element mutably and returns an array of mutable references\nwith the same size as Divides one array reference into two at an index. The first will contain all indices from Panics if Divides one mutable array reference into two at an index. The first will contain all indices from Panics if Divides one array reference into two at an index from the end. The first will contain all indices from Panics if Divides one mutable array reference into two at an index from the end. The first will contain all indices from Panics if Note that overly-large arrays may cause the conversions to fail. This trait is implemented for tuples up to twelve items long. The hash of an array is the same as that of the corresponding slice,\nas required by the Creates a consuming iterator, that is, one that moves each value out of\nthe array (from start to end). The array cannot be used after calling this unless Arrays have special behavior when calling Implements comparison of arrays lexicographically. ","mito2::sst::version::LevelMetaArray"],[" Implements comparison of arrays lexicographically. Tries to create an array Tries to create an array Gets the entire contents of the If the length doesn’t match, the input comes back in If you’re fine with just getting a prefix of the Gets the entire contents of the If the length doesn’t match, the input comes back in If you’re fine with just getting a prefix of the Impl [ Impl [impl<T, U, const N: usize> PartialEq<&[U]> for [T; N]
impl<T, U, const N: usize> PartialEq<&mut [U]> for [T; N]
impl<T, U, const N: usize> PartialEq<[U]> for [T; N]
impl<T, U, const N: usize> PartialEq<[U; N]> for [T; N]
impl<T, const N: usize> PartialOrd for [T; N]
impl<S, const N: usize> Point for [S; N]
const DIMENSIONS: usize = N
fn generate(generator: impl FnMut(usize) -> S) -> [S; N]
impl<T> Serialize for [T; 3]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T, As, const N: usize> SerializeAs<[T; N]> for [As; N]
fn serialize_as<S>(\n array: &[T; N],\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T, const N: usize> SlicePattern for [T; N]
impl<T, const N: usize> ToSql for [T; N]
array-impls only.fn to_sql(\n &self,\n ty: &Type,\n w: &mut BytesMut,\n) -> Result<IsNull, Box<dyn Error + Send + Sync>>
self into the binary format of the specified\nPostgres Type, appending it to out. Read morefn accepts(ty: &Type) -> bool
Type.fn to_sql_checked(\n &self,\n ty: &Type,\n out: &mut BytesMut,\n) -> Result<IsNull, Box<dyn Error + Send + Sync>>
fn encode_format(&self, _ty: &Type) -> Format
impl<T, const N: usize> TryFrom<&[T]> for [T; N]
[T; N] by copying from a slice &[T].\nSucceeds if slice.len() == N.let bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]
[T; N] by copying from a mutable slice &mut [T].\nSucceeds if slice.len() == N.let mut bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&mut bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]
fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
Vec<T> as an array,\nif its size exactly matches that of the requested array.§Examples
\nassert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));\nassert_eq!(<Vec<i32>>::new().try_into(), Ok([]));Err:let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();\nassert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));Vec<T>,\nyou can call .truncate(N) first.let mut v = String::from(\"hello world\").into_bytes();\nv.sort();\nv.truncate(2);\nlet [a, b]: [_; 2] = v.try_into().unwrap();\nassert_eq!(a, b' ');\nassert_eq!(b, b'd');impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]
fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
Vec<T> as an array,\nif its size exactly matches that of the requested array.§Examples
\nassert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));\nassert_eq!(<Vec<i32>>::new().try_into(), Ok([]));Err:let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();\nassert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));Vec<T>,\nyou can call .truncate(N) first.let mut v = String::from(\"hello world\").into_bytes();\nv.sort();\nv.truncate(2);\nlet [a, b]: [_; 2] = v.try_into().unwrap();\nassert_eq!(a, b' ');\nassert_eq!(b, b'd');impl<T, const N: usize> TryFromBytes for [T; N]
fn try_ref_from_bytes(\n source: &[u8],\n) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_ref_from_prefix(\n source: &[u8],\n) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_ref_from_suffix(\n source: &[u8],\n) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_mut_from_bytes(\n bytes: &mut [u8],\n) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_mut_from_prefix(\n source: &mut [u8],\n) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_mut_from_suffix(\n source: &mut [u8],\n) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_ref_from_bytes_with_elems(\n source: &[u8],\n count: usize,\n) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_ref_from_prefix_with_elems(\n source: &[u8],\n count: usize,\n) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
source as a &Self with\na DST length equal to count. Read morefn try_ref_from_suffix_with_elems(\n source: &[u8],\n count: usize,\n) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
source as a &Self with\na DST length equal to count. Read morefn try_mut_from_bytes_with_elems(\n source: &mut [u8],\n count: usize,\n) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_mut_from_prefix_with_elems(\n source: &mut [u8],\n count: usize,\n) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
source as a &mut Self\nwith a DST length equal to count. Read morefn try_mut_from_suffix_with_elems(\n source: &mut [u8],\n count: usize,\n) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
source as a &mut Self\nwith a DST length equal to count. Read morefn try_read_from_bytes(\n source: &[u8],\n) -> Result<Self, ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_read_from_prefix(\n source: &[u8],\n) -> Result<(Self, &[u8]), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_read_from_suffix(\n source: &[u8],\n) -> Result<(&[u8], Self), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
impl<T, const N: usize> ULE for [T; N]
fn parse_bytes_to_slice(bytes: &[u8]) -> Result<&[Self], UleError>
unsafe fn slice_from_bytes_unchecked(bytes: &[u8]) -> &[Self]
&[u8], and return it as &[Self] with the same lifetime, assuming\nthat this byte slice has previously been run through [Self::parse_bytes_to_slice()] with\nsuccess. Read morefn slice_as_bytes(slice: &[Self]) -> &[u8] ⓘ
impl<T, const N: usize> UnsizedCopy for [T; N]
fn ptr_with_addr(&self, addr: *const ()) -> *const [T; N]
Self. Read morefn unsized_copy_into<T>(&self) -> T
self into a new container. Read moreimpl<'a, T, const N: usize> Yokeable<'a> for [T; N]
type Output = [<T as Yokeable<'a>>::Output; N]
Self with the 'static replaced with 'a, i.e. Self<'a>fn transform_owned(self) -> <[T; N] as Yokeable<'a>>::Output
unsafe fn make(from: <[T; N] as Yokeable<'a>>::Output) -> [T; N]
Self<'a>’s lifetime. Read morefn transform_mut<F>(&'a mut self, f: F)
self between &'a mut Self<'static> and &'a mut Self<'a>,\nand pass it to f. Read moreimpl<'a, T, const N: usize> ZeroMapKV<'a> for [T; N]
impl<Z, const N: usize> Zeroize for [Z; N]
Zeroize] on arrays of types that impl [Zeroize].impl<T, const N: usize> CloneFromCell for [T; N]
impl<T, const N: usize> ConstParamTy_ for [T; N]
impl<T, const N: usize> Copy for [T; N]
impl<T, const N: usize> Eq for [T; N]
impl<T, const N: usize> EqULE for [T; N]
impl<T, const N: usize> Immutable for [T; N]
impl<T> Pod for [T; 3]
impl<const N: usize, T> Pod for [T; N]
impl<T, const N: usize> StructuralPartialEq for [T; N]
impl<T, const N: usize> Unaligned for [T; N]
impl<Z, const N: usize> ZeroizeOnDrop for [Z; N]
ZeroizeOnDrop] on arrays of types that impl [ZeroizeOnDrop].impl<T, const N: usize> [T; N]
pub fn map<F, U>(self, f: F) -> [U; N]
self, with function f applied to each element\nin order.Iterator::map instead.§Note on performance and stack usage
\nf all N times before\nreturning the new array.arr.map(f).map(g) is, in general, not equivalent to\narray.map(|x| g(f(x))), as the former calls f 4 times then g 4 times,\nwhereas the latter interleaves the calls (fgfgfgfg).map and really want an array as the result,\nthen absolutely use this method. Its implementation uses a bunch of tricks\nto help the optimizer handle it well. Particularly for simple arrays,\nlike [u8; 3] or [f32; 4], there’s nothing to be concerned about.Iterator::map instead.for x in my_array.map(f) {\n // ...\n}for x in my_array.into_iter().map(f) {\n // ...\n}§Examples
\nlet x = [1, 2, 3];\nlet y = x.map(|v| v + 1);\nassert_eq!(y, [2, 3, 4]);\n\nlet x = [1, 2, 3];\nlet mut temp = 0;\nlet y = x.map(|v| { temp += 1; v * temp });\nassert_eq!(y, [1, 4, 9]);\n\nlet x = [\"Ferris\", \"Bueller's\", \"Day\", \"Off\"];\nlet y = x.map(|v| v.len());\nassert_eq!(y, [6, 9, 3, 3]);pub const fn try_map<R>(\n self,\n f: impl FnMut(T) -> R,\n) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryType
array_try_map)f applied to each element on array self in order to\nreturn an array the same size as self or the first error encountered.Result<T, E> from the closure, you’ll get a Result<[T; N], E>.\nIf you return Option<T> from the closure, you’ll get an Option<[T; N]>.§Examples
\n#![feature(array_try_map)]\n\nlet a = [\"1\", \"2\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);\nassert_eq!(b, [2, 3, 4]);\n\nlet a = [\"1\", \"2a\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>());\nassert!(b.is_err());\n\nuse std::num::NonZero;\n\nlet z = [1, 2, 0, 3, 4];\nassert_eq!(z.try_map(NonZero::new), None);\n\nlet a = [1, 2, 3];\nlet b = a.try_map(NonZero::new);\nlet c = b.map(|x| x.map(NonZero::get));\nassert_eq!(c, Some(a));pub const fn as_slice(&self) -> &[T]
&s[..].pub const fn as_mut_slice(&mut self) -> &mut [T]
&mut s[..].pub const fn each_ref(&self) -> [&T; N]
self.§Example
\nlet floats = [3.1, 2.7, -1.0];\nlet float_refs: [&f64; 3] = floats.each_ref();\nassert_eq!(float_refs, [&3.1, &2.7, &-1.0]);map. This way, you can avoid moving the original\narray if its elements are not Copy.let strings = [\"Ferris\".to_string(), \"♥\".to_string(), \"Rust\".to_string()];\nlet is_ascii = strings.each_ref().map(|s| s.is_ascii());\nassert_eq!(is_ascii, [true, false, true]);\n\n// We can still access the original array: it has not been moved.\nassert_eq!(strings.len(), 3);pub const fn each_mut(&mut self) -> [&mut T; N]
self.§Example
\n\nlet mut floats = [3.1, 2.7, -1.0];\nlet float_refs: [&mut f64; 3] = floats.each_mut();\n*float_refs[0] = 0.0;\nassert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);\nassert_eq!(floats, [0.0, 2.7, -1.0]);pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])
split_array)[0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).§Panics
\nM > N.§Examples
\n#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n let (left, right) = v.split_array_ref::<0>();\n assert_eq!(left, &[]);\n assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}\n\n{\n let (left, right) = v.split_array_ref::<2>();\n assert_eq!(left, &[1, 2]);\n assert_eq!(right, &[3, 4, 5, 6]);\n}\n\n{\n let (left, right) = v.split_array_ref::<6>();\n assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n assert_eq!(right, &[]);\n}pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])
split_array)[0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).§Panics
\nM > N.§Examples
\n#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.split_array_mut::<2>();\nassert_eq!(left, &mut [1, 0][..]);\nassert_eq!(right, &mut [3, 0, 5, 6]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])
split_array)[0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).§Panics
\nM > N.§Examples
\n#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n let (left, right) = v.rsplit_array_ref::<0>();\n assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n assert_eq!(right, &[]);\n}\n\n{\n let (left, right) = v.rsplit_array_ref::<2>();\n assert_eq!(left, &[1, 2, 3, 4]);\n assert_eq!(right, &[5, 6]);\n}\n\n{\n let (left, right) = v.rsplit_array_ref::<6>();\n assert_eq!(left, &[]);\n assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])
split_array)[0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).§Panics
\nM > N.§Examples
\n#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.rsplit_array_mut::<4>();\nassert_eq!(left, &mut [1, 0]);\nassert_eq!(right, &mut [3, 0, 5, 6][..]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);impl<const N: usize, I, O, E, P> Alt<I, O, E> for [P; N]
impl<T> Array for [T; 0]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 1]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 10]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 1024]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 11]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 12]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 128]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 13]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 14]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 15]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 16]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 17]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 18]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 19]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 2]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 20]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 2048]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 21]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 22]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 23]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 24]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 25]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 256]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 26]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 27]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 28]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 29]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 3]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 30]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 31]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 32]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 33]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 4]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 4096]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 5]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 512]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 6]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 64]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 7]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 8]
fn as_slice_mut(&mut self) -> &mut [T]
impl<T> Array for [T; 9]
fn as_slice_mut(&mut self) -> &mut [T]
impl<A, B, const N: usize> AssertFloatEq<[B; N]> for [A; N]
type DebugAbsDiff = [<A as AssertFloatEq<B>>::DebugAbsDiff; N]
fmt::Debug when an assert fails. Read moretype DebugTol = [<A as AssertFloatEq<B>>::DebugTol; N]
fmt::Debug when an assert fails. Read morefn debug_abs_diff(\n &self,\n other: &[B; N],\n) -> <[A; N] as AssertFloatEq<[B; N]>>::DebugAbsDiff
fn debug_ulps_diff(\n &self,\n other: &[B; N],\n) -> <<[A; N] as AssertFloatEq<[B; N]>>::DebugAbsDiff as FloatEqDebugUlpsDiff>::DebugUlpsDiff
fn debug_abs_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEq<[B; N]>>::Tol,\n) -> <[A; N] as AssertFloatEq<[B; N]>>::DebugTol
abs comparison, displayed when an assert fails.fn debug_rmax_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEq<[B; N]>>::Tol,\n) -> <[A; N] as AssertFloatEq<[B; N]>>::DebugTol
fn debug_rmin_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEq<[B; N]>>::Tol,\n) -> <[A; N] as AssertFloatEq<[B; N]>>::DebugTol
fn debug_r1st_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEq<[B; N]>>::Tol,\n) -> <[A; N] as AssertFloatEq<[B; N]>>::DebugTol
fn debug_r2nd_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEq<[B; N]>>::Tol,\n) -> <[A; N] as AssertFloatEq<[B; N]>>::DebugTol
fn debug_ulps_tol(\n &self,\n other: &[B; N],\n tol: &<<[A; N] as FloatEq<[B; N]>>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> <<[A; N] as AssertFloatEq<[B; N]>>::DebugTol as FloatEqUlpsTol>::UlpsTol
ulps comparison, displayed when an assert fails.fn debug_rel_tol(&self, other: &Rhs, tol: &Self::Tol) -> Self::DebugTol
impl<A, B, const N: usize> AssertFloatEqAll<[B; N]> for [A; N]
type AllDebugTol = [<A as AssertFloatEqAll<B>>::AllDebugTol; N]
fmt::Debug. Read morefn debug_abs_all_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> <[A; N] as AssertFloatEqAll<[B; N]>>::AllDebugTol
abs_all comparison, displayed when an assert fails.fn debug_rmax_all_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> <[A; N] as AssertFloatEqAll<[B; N]>>::AllDebugTol
fn debug_rmin_all_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> <[A; N] as AssertFloatEqAll<[B; N]>>::AllDebugTol
fn debug_r1st_all_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> <[A; N] as AssertFloatEqAll<[B; N]>>::AllDebugTol
fn debug_r2nd_all_tol(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> <[A; N] as AssertFloatEqAll<[B; N]>>::AllDebugTol
fn debug_ulps_all_tol(\n &self,\n other: &[B; N],\n tol: &<<[A; N] as FloatEqAll<[B; N]>>::AllTol as FloatEqUlpsTol>::UlpsTol,\n) -> <<[A; N] as AssertFloatEqAll<[B; N]>>::AllDebugTol as FloatEqUlpsTol>::UlpsTol
ulps_all comparison, displayed when an assert fails.fn debug_rel_all_tol(\n &self,\n other: &Rhs,\n tol: &Self::AllTol,\n) -> Self::AllDebugTol
impl<T, const N: usize> BitView for [T; N]
tarpaulin_include only.fn view_bits<O>(&self) -> &BitSlice<T, O> ⓘ
fn try_view_bits<O>(&self) -> Result<&BitSlice<T, O>, BitSpanError<T>>
fn view_bits_mut<O>(&mut self) -> &mut BitSlice<T, O> ⓘ
fn try_view_bits_mut<O>(\n &mut self,\n) -> Result<&mut BitSlice<T, O>, BitSpanError<T>>
impl<T, const N: usize> BitViewSized for [T; N]
fn as_raw_slice(&self) -> &[<[T; N] as BitView>::Store]
fn as_raw_mut_slice(&mut self) -> &mut [<[T; N] as BitView>::Store]
fn into_bitarray<O>(self) -> BitArray<Self, O>
self in a BitArray.impl<T, const N: usize> BorrowMut<[T]> for [T; N]
fn borrow_mut(&mut self) -> &mut [T]
impl<'r, T, const N: usize> Decode<'r, Postgres> for [T; N]
impl<'a, T, const N: usize> DecodeValue<'a> for [T; N]
fn decode_value<R>(reader: &mut R, header: Header) -> Result<[T; N], Error>
Reader].impl<'de, T> Deserialize<'de> for [T; 0]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 0], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 1]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 1], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 10]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 10], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 11]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 11], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 12]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 12], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 13]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 13], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 14]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 14], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 15]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 15], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 16]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 16], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 17]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 17], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 18]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 18], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 19]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 19], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 2]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 2], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 20]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 20], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 21]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 21], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 22]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 22], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 23]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 23], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 24]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 24], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 25]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 25], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 26]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 26], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 27]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 27], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 28]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 28], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 29]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 29], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 3]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 3], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 30]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 30], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 31]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 31], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 32]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 32], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 4]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 4], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 5]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 5], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 6]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 6], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 7]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 7], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 8]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 8], <D as Deserializer<'de>>::Error>
impl<'de, T> Deserialize<'de> for [T; 9]
fn deserialize<D>(\n deserializer: D,\n) -> Result<[T; 9], <D as Deserializer<'de>>::Error>
impl<'de, T, As, const N: usize> DeserializeAs<'de, [T; N]> for [As; N]
fn deserialize_as<D>(\n deserializer: D,\n) -> Result<[T; N], <D as Deserializer<'de>>::Error>
impl<'q, T, const N: usize> Encode<'q, Postgres> for [T; N]
fn encode_by_ref(\n &self,\n buf: &mut PgArgumentBuffer,\n) -> Result<IsNull, Box<dyn Error + Send + Sync>>
fn encode(\n self,\n buf: &mut <DB as Database>::ArgumentBuffer<'q>,\n) -> Result<IsNull, Box<dyn Error + Send + Sync>>
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
impl<T, const N: usize> EncodeValue for [T; N]
impl<A, B, const N: usize> FloatEq<[B; N]> for [A; N]
type Tol = [<A as FloatEq<B>>::Tol; N]
fn eq_rmax(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEq<[B; N]>>::Tol,\n) -> bool
self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the largest\nmagnitude. Read morefn eq_rmin(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEq<[B; N]>>::Tol,\n) -> bool
self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the smallest\nmagnitude. Read morefn eq_r1st(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEq<[B; N]>>::Tol,\n) -> bool
self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the first input. Read morefn eq_r2nd(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEq<[B; N]>>::Tol,\n) -> bool
self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the second input. Read morefn eq_ulps(\n &self,\n other: &[B; N],\n tol: &<<[A; N] as FloatEq<[B; N]>>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool
impl<A, B, const N: usize> FloatEqAll<[B; N]> for [A; N]
type AllTol = <A as FloatEqAll<B>>::AllTol
fn eq_abs_all(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> bool
fn eq_rmax_all(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> bool
fn eq_rmin_all(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> bool
fn eq_r1st_all(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> bool
fn eq_r2nd_all(\n &self,\n other: &[B; N],\n tol: &<[A; N] as FloatEqAll<[B; N]>>::AllTol,\n) -> bool
fn eq_ulps_all(\n &self,\n other: &[B; N],\n tol: &<<[A; N] as FloatEqAll<[B; N]>>::AllTol as FloatEqUlpsTol>::UlpsTol,\n) -> bool
fn ne_abs_all(&self, other: &Rhs, tol: &Self::AllTol) -> bool
fn eq_rel_all(&self, other: &Rhs, tol: &Self::AllTol) -> bool
fn ne_rel_all(&self, other: &Rhs, tol: &Self::AllTol) -> bool
fn ne_rmax_all(&self, other: &Rhs, tol: &Self::AllTol) -> bool
fn ne_rmin_all(&self, other: &Rhs, tol: &Self::AllTol) -> bool
fn ne_r1st_all(&self, other: &Rhs, tol: &Self::AllTol) -> bool
fn ne_r2nd_all(&self, other: &Rhs, tol: &Self::AllTol) -> bool
fn ne_ulps_all(\n &self,\n other: &Rhs,\n tol: &<Self::AllTol as FloatEqUlpsTol>::UlpsTol,\n) -> bool
impl<T, const N: usize> FloatEqDebugUlpsDiff for [T; N]
type DebugUlpsDiff = [<T as FloatEqDebugUlpsDiff>::DebugUlpsDiff; N]
Self, with fields recursively wrapped\nby DebugUlpsDiff.impl<T, const N: usize> FloatEqUlpsTol for [T; N]
impl<T> From<(T₁, T₂, …, Tₙ)> for [T; N]
impl<'a, T, const N: usize> From<Array<'a, T, N>> for [<T as Follow<'a>>::Inner; N]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 1024]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 512]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 1000]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 256]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 300]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 400]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 500]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 128]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>> for [T; 200]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 64]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>> for [T; 70]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 80]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>> for [T; 90]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 100]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>> for [T; 32]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>> for [T; 33]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>> for [T; 34]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>> for [T; 35]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 36]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>> for [T; 37]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>> for [T; 38]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>> for [T; 39]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 40]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>> for [T; 41]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>> for [T; 42]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>> for [T; 43]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 44]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>> for [T; 45]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>> for [T; 46]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>> for [T; 47]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>> for [T; 48]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>> for [T; 49]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>> for [T; 50]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>> for [T; 51]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 52]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>> for [T; 53]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>> for [T; 54]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>> for [T; 55]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>> for [T; 56]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>> for [T; 57]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>> for [T; 58]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>> for [T; 59]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>> for [T; 60]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>> for [T; 61]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>> for [T; 62]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>> for [T; 63]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>> for [T; 16]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>> for [T; 17]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>> for [T; 18]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>> for [T; 19]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>> for [T; 20]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>> for [T; 21]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>> for [T; 22]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>> for [T; 23]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>> for [T; 24]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>> for [T; 25]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>> for [T; 26]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>> for [T; 27]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>> for [T; 28]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>> for [T; 29]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>> for [T; 30]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>> for [T; 31]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>> for [T; 8]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>> for [T; 9]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>> for [T; 10]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>> for [T; 11]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>> for [T; 12]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>> for [T; 13]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>> for [T; 14]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>> for [T; 15]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>> for [T; 4]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>> for [T; 5]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>> for [T; 6]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>> for [T; 7]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B0>>> for [T; 2]
relaxed_coherence only.impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B1>>> for [T; 3]
relaxed_coherence only.impl<T, const D: usize> From<Matrix<T, Const<1>, Const<D>, ArrayStorage<T, 1, D>>> for [T; D]
impl<T, const D: usize> From<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for [T; D]
impl<'a, T, RStride, CStride, const D: usize> From<Matrix<T, Const<D>, Const<1>, ViewStorage<'a, T, Const<D>, Const<1>, RStride, CStride>>> for [T; D]
impl<'a, T, RStride, CStride, const D: usize> From<Matrix<T, Const<D>, Const<1>, ViewStorageMut<'a, T, Const<D>, Const<1>, RStride, CStride>>> for [T; D]
impl<T, const D: usize> From<Translation<T, D>> for [T; D]
fn from(t: Translation<T, D>) -> [T; D]
impl<T, const N: usize> FromBytes for [T; N]
fn ref_from_bytes(\n source: &[u8],\n) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>
fn ref_from_prefix(\n source: &[u8],\n) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>
fn ref_from_suffix(\n source: &[u8],\n) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>
&Self. Read morefn mut_from_bytes(\n source: &mut [u8],\n) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>
fn mut_from_prefix(\n source: &mut [u8],\n) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>
fn mut_from_suffix(\n source: &mut [u8],\n) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>
fn ref_from_bytes_with_elems(\n source: &[u8],\n count: usize,\n) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>
fn ref_from_prefix_with_elems(\n source: &[u8],\n count: usize,\n) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>
fn ref_from_suffix_with_elems(\n source: &[u8],\n count: usize,\n) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>
fn mut_from_bytes_with_elems(\n source: &mut [u8],\n count: usize,\n) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>
fn mut_from_prefix_with_elems(\n source: &mut [u8],\n count: usize,\n) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>
fn mut_from_suffix_with_elems(\n source: &mut [u8],\n count: usize,\n) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>
impl<'a, T, const N: usize> FromSql<'a> for [T; N]
array-impls only.fn from_sql(\n ty: &Type,\n raw: &'a [u8],\n) -> Result<[T; N], Box<dyn Error + Send + Sync>>
Type in its binary format. Read morefn accepts(ty: &Type) -> bool
Type.impl<T, const N: usize> Hash for [T; N]
Borrow implementation.use std::hash::BuildHasher;\n\nlet b = std::hash::RandomState::new();\nlet a: [u8; 3] = [0xa8, 0x3c, 0x09];\nlet s: &[u8] = &[0xa8, 0x3c, 0x09];\nassert_eq!(b.hash_one(a), b.hash_one(s));impl<T, const N: usize> IntoBytes for [T; N]
fn as_mut_bytes(&mut self) -> &mut [u8] ⓘ
fn write_to(&self, dst: &mut [u8]) -> Result<(), SizeError<&Self, &mut [u8]>>
impl<T, const N: usize> IntoIterator for [T; N]
fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter
T implements\nCopy, so the whole array is copied..into_iter() prior to the\n2021 edition – see the array Editions section for more information.impl<T, const N: usize> KnownLayout for [T; N]
type PointerMetadata = ()
Self. Read moreimpl<T, const N: usize> MaybeAsVarULE for [T; N]
type EncodedStruct = [()]
VarULE] type for this data struct, or [()]\nif it cannot be represented as [VarULE].impl<T, const N: usize> Ord for [T; N]
fn max(self, other: Self) -> Self
impl<P, T, const N: usize> OverlayResource<P, T> for [P; N]
type ResourceIter<'a> = SingleResourceIterator<'a, P>\nwhere\n P: 'a,\n [P; N]: 'a
fn iter_paths(&self) -> <[P; N] as OverlayResource<P, T>>::ResourceIter<'_>
impl<T, U, const N: usize> PartialEq<&[U]> for [T; N]
impl<T, U, const N: usize> PartialEq<&mut [U]> for [T; N]
impl<T, U, const N: usize> PartialEq<[U]> for [T; N]
impl<T, U, const N: usize> PartialEq<[U; N]> for [T; N]
impl<T, const N: usize> PartialOrd for [T; N]
impl<S, const N: usize> Point for [S; N]
const DIMENSIONS: usize = N
fn generate(generator: impl FnMut(usize) -> S) -> [S; N]
impl<T> Serialize for [T; 0]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 1]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 10]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 11]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 12]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 13]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 14]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 15]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 16]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 17]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 18]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 19]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 2]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 20]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 21]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 22]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 23]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 24]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 25]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 26]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 27]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 28]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 29]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 3]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 30]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 31]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 32]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 4]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 5]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 6]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 7]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 8]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T> Serialize for [T; 9]
fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T, As, const N: usize> SerializeAs<[T; N]> for [As; N]
fn serialize_as<S>(\n array: &[T; N],\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
impl<T, const N: usize> SlicePattern for [T; N]
impl<T, const N: usize> ToSql for [T; N]
array-impls only.fn to_sql(\n &self,\n ty: &Type,\n w: &mut BytesMut,\n) -> Result<IsNull, Box<dyn Error + Send + Sync>>
self into the binary format of the specified\nPostgres Type, appending it to out. Read morefn accepts(ty: &Type) -> bool
Type.fn to_sql_checked(\n &self,\n ty: &Type,\n out: &mut BytesMut,\n) -> Result<IsNull, Box<dyn Error + Send + Sync>>
fn encode_format(&self, _ty: &Type) -> Format
impl<T, const N: usize> TryFrom<&[T]> for [T; N]
[T; N] by copying from a slice &[T].\nSucceeds if slice.len() == N.let bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]
[T; N] by copying from a mutable slice &mut [T].\nSucceeds if slice.len() == N.let mut bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&mut bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]
fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
Vec<T> as an array,\nif its size exactly matches that of the requested array.§Examples
\nassert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));\nassert_eq!(<Vec<i32>>::new().try_into(), Ok([]));Err:let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();\nassert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));Vec<T>,\nyou can call .truncate(N) first.let mut v = String::from(\"hello world\").into_bytes();\nv.sort();\nv.truncate(2);\nlet [a, b]: [_; 2] = v.try_into().unwrap();\nassert_eq!(a, b' ');\nassert_eq!(b, b'd');impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]
fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
Vec<T> as an array,\nif its size exactly matches that of the requested array.§Examples
\nassert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));\nassert_eq!(<Vec<i32>>::new().try_into(), Ok([]));Err:let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();\nassert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));Vec<T>,\nyou can call .truncate(N) first.let mut v = String::from(\"hello world\").into_bytes();\nv.sort();\nv.truncate(2);\nlet [a, b]: [_; 2] = v.try_into().unwrap();\nassert_eq!(a, b' ');\nassert_eq!(b, b'd');impl<T, const N: usize> TryFromBytes for [T; N]
fn try_ref_from_bytes(\n source: &[u8],\n) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_ref_from_prefix(\n source: &[u8],\n) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_ref_from_suffix(\n source: &[u8],\n) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_mut_from_bytes(\n bytes: &mut [u8],\n) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_mut_from_prefix(\n source: &mut [u8],\n) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_mut_from_suffix(\n source: &mut [u8],\n) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_ref_from_bytes_with_elems(\n source: &[u8],\n count: usize,\n) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_ref_from_prefix_with_elems(\n source: &[u8],\n count: usize,\n) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
source as a &Self with\na DST length equal to count. Read morefn try_ref_from_suffix_with_elems(\n source: &[u8],\n count: usize,\n) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
source as a &Self with\na DST length equal to count. Read morefn try_mut_from_bytes_with_elems(\n source: &mut [u8],\n count: usize,\n) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_mut_from_prefix_with_elems(\n source: &mut [u8],\n count: usize,\n) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
source as a &mut Self\nwith a DST length equal to count. Read morefn try_mut_from_suffix_with_elems(\n source: &mut [u8],\n count: usize,\n) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
source as a &mut Self\nwith a DST length equal to count. Read morefn try_read_from_bytes(\n source: &[u8],\n) -> Result<Self, ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_read_from_prefix(\n source: &[u8],\n) -> Result<(Self, &[u8]), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_read_from_suffix(\n source: &[u8],\n) -> Result<(&[u8], Self), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
impl<T, const N: usize> ULE for [T; N]
fn parse_bytes_to_slice(bytes: &[u8]) -> Result<&[Self], UleError>
unsafe fn slice_from_bytes_unchecked(bytes: &[u8]) -> &[Self]
&[u8], and return it as &[Self] with the same lifetime, assuming\nthat this byte slice has previously been run through [Self::parse_bytes_to_slice()] with\nsuccess. Read morefn slice_as_bytes(slice: &[Self]) -> &[u8] ⓘ
impl<'a, T, const N: usize> Yokeable<'a> for [T; N]
type Output = [<T as Yokeable<'a>>::Output; N]
Self with the 'static replaced with 'a, i.e. Self<'a>fn transform_owned(self) -> <[T; N] as Yokeable<'a>>::Output
unsafe fn make(from: <[T; N] as Yokeable<'a>>::Output) -> [T; N]
Self<'a>’s lifetime. Read morefn transform_mut<F>(&'a mut self, f: F)
self between &'a mut Self<'static> and &'a mut Self<'a>,\nand pass it to f. Read moreimpl<'a, T, const N: usize> ZeroMapKV<'a> for [T; N]
impl<Z, const N: usize> Zeroize for [Z; N]
Zeroize] on arrays of types that impl [Zeroize].impl<T, const N: usize> CloneFromCell for [T; N]
impl<T, const N: usize> ConstParamTy_ for [T; N]
impl<T, const N: usize> Copy for [T; N]
impl<T, const N: usize> Eq for [T; N]
impl<T, const N: usize> EqULE for [T; N]
impl<T, const N: usize> Immutable for [T; N]
impl<T> Pod for [T; 0]
impl<T> Pod for [T; 1]
impl<T> Pod for [T; 10]
impl<T> Pod for [T; 1024]
impl<T> Pod for [T; 11]
impl<T> Pod for [T; 12]
impl<T> Pod for [T; 128]
impl<T> Pod for [T; 13]
impl<T> Pod for [T; 14]
impl<T> Pod for [T; 15]
impl<T> Pod for [T; 16]
impl<T> Pod for [T; 17]
impl<T> Pod for [T; 18]
impl<T> Pod for [T; 19]
impl<T> Pod for [T; 2]
impl<T> Pod for [T; 20]
impl<T> Pod for [T; 2048]
impl<T> Pod for [T; 21]
impl<T> Pod for [T; 22]
impl<T> Pod for [T; 23]
impl<T> Pod for [T; 24]
impl<T> Pod for [T; 25]
impl<T> Pod for [T; 256]
impl<T> Pod for [T; 26]
impl<T> Pod for [T; 27]
impl<T> Pod for [T; 28]
impl<T> Pod for [T; 29]
impl<T> Pod for [T; 3]
impl<T> Pod for [T; 30]
impl<T> Pod for [T; 31]
impl<T> Pod for [T; 32]
impl<T> Pod for [T; 4]
impl<T> Pod for [T; 4096]
impl<T> Pod for [T; 48]
impl<T> Pod for [T; 5]
impl<T> Pod for [T; 512]
impl<T> Pod for [T; 6]
impl<T> Pod for [T; 64]
impl<T> Pod for [T; 7]
impl<T> Pod for [T; 8]
impl<T> Pod for [T; 9]
impl<T> Pod for [T; 96]
impl<const N: usize, T> Pod for [T; N]
impl<T, const N: usize> StructuralPartialEq for [T; N]
impl<T, const N: usize> Unaligned for [T; N]
impl<Z, const N: usize> ZeroizeOnDrop for [Z; N]
ZeroizeOnDrop] on arrays of types that impl [ZeroizeOnDrop].