Primitive Type slice
[-] [+]
Utilities for slice manipulation
The slice
module contains useful code to help work with slice values.
Slices are a view into a block of memory represented as a pointer and a length.
// slicing a Vec let vec = vec!(1, 2, 3); let int_slice = vec.as_slice(); // coercing an array to a slice let str_slice: &[&str] = &["one", "two", "three"];
Slices are either mutable or shared. The shared slice type is &[T]
,
while the mutable slice type is &mut[T]
. For example, you can mutate the
block of memory that a mutable slice points to:
let x: &mut[i32] = &mut [1, 2, 3]; x[1] = 7; assert_eq!(x[0], 1); assert_eq!(x[1], 7); assert_eq!(x[2], 3);
Here are some of the things this module contains:
Structs
There are several structs that are useful for slices, such as Iter
, which
represents iteration over a slice.
Traits
A number of traits add methods that allow you to accomplish tasks
with slices, the most important being SliceExt
. Other traits
apply only to slices of elements satisfying certain bounds (like
Ord
).
An example is the slice
method which enables slicing syntax [a..b]
that
returns an immutable "view" into a Vec
or another slice from the index
interval [a, b)
:
fn main() { let numbers = [0, 1, 2]; let last_numbers = &numbers[1..3]; // last_numbers is now &[1, 2] }
Implementations of other traits
There are several implementations of common traits for slices. Some examples include:
Clone
Eq
,Ord
- for immutable slices whose element type areEq
orOrd
.Hash
- for slices whose element type isHash
Iteration
The method iter()
returns an iteration value for a slice. The iterator
yields references to the slice's elements, so if the element
type of the slice is isize
, the element type of the iterator is &isize
.
let numbers = [0, 1, 2]; for &x in numbers.iter() { println!("{} is a number!", x); }
.iter_mut()
returns an iterator that allows modifying each value.- Further iterators exist that split, chunk or permute the slice.
Trait Implementations
impl<T> Repr<Slice<T>> for [T]
impl<T> SliceExt for [T]
type Item = T
fn split_at(&self, mid: usize) -> (&[T], &[T])
fn iter(&'a self) -> Iter<'a, T>
fn split<P>(&'a self, pred: P) -> Split<'a, T, P> where P: FnMut(&T), <P as FnMut(&T)>::Output == bool
fn splitn<P>(&'a self, n: usize, pred: P) -> SplitN<'a, T, P> where P: FnMut(&T), <P as FnMut(&T)>::Output == bool
fn rsplitn<P>(&'a self, n: usize, pred: P) -> RSplitN<'a, T, P> where P: FnMut(&T), <P as FnMut(&T)>::Output == bool
fn windows(&self, size: usize) -> Windows<T>
fn chunks(&self, size: usize) -> Chunks<T>
fn get(&self, index: usize) -> Option<&T>
fn first(&self) -> Option<&T>
fn tail(&self) -> &[T]
fn init(&self) -> &[T]
fn last(&self) -> Option<&T>
unsafe fn get_unchecked(&self, index: usize) -> &T
fn as_ptr(&self) -> *const T
fn binary_search_by<F>(&self, f: F) -> Result<usize, usize> where F: FnMut(&T), <F as FnMut(&T)>::Output == Ordering
fn len(&self) -> usize
fn get_mut(&mut self, index: usize) -> Option<&mut T>
fn as_mut_slice(&mut self) -> &mut [T]
fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])
fn iter_mut(&'a mut self) -> IterMut<'a, T>
fn last_mut(&mut self) -> Option<&mut T>
fn first_mut(&mut self) -> Option<&mut T>
fn tail_mut(&mut self) -> &mut [T]
fn init_mut(&mut self) -> &mut [T]
fn split_mut<P>(&'a mut self, pred: P) -> SplitMut<'a, T, P> where P: FnMut(&T), <P as FnMut(&T)>::Output == bool
fn splitn_mut<P>(&'a mut self, n: usize, pred: P) -> SplitNMut<'a, T, P> where P: FnMut(&T), <P as FnMut(&T)>::Output == bool
fn rsplitn_mut<P>(&'a mut self, n: usize, pred: P) -> RSplitNMut<'a, T, P> where P: FnMut(&T), <P as FnMut(&T)>::Output == bool
fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T>
fn swap(&mut self, a: usize, b: usize)
fn reverse(&mut self)
unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T
fn as_mut_ptr(&mut self) -> *mut T
fn position_elem(&self, x: &T) -> Option<usize> where T: PartialEq<T>
fn rposition_elem(&self, t: &T) -> Option<usize> where T: PartialEq<T>
fn contains(&self, x: &T) -> bool where T: PartialEq<T>
fn starts_with(&self, needle: &[T]) -> bool where T: PartialEq<T>
fn ends_with(&self, needle: &[T]) -> bool where T: PartialEq<T>
fn binary_search(&self, x: &T) -> Result<usize, usize> where T: Ord
fn next_permutation(&mut self) -> bool where T: Ord
fn prev_permutation(&mut self) -> bool where T: Ord
fn clone_from_slice(&mut self, src: &[T]) -> usize where T: Clone
fn is_empty(&self) -> bool
impl<T> Index<usize> for [T]
impl<T> IndexMut<usize> for [T]
impl<T> Index<Range<usize>> for [T]
impl<T> Index<RangeTo<usize>> for [T]
impl<T> Index<RangeFrom<usize>> for [T]
impl<T> Index<RangeFull> for [T]
impl<T> IndexMut<Range<usize>> for [T]
impl<T> IndexMut<RangeTo<usize>> for [T]
impl<T> IndexMut<RangeFrom<usize>> for [T]
impl<T> IndexMut<RangeFull> for [T]
impl<T> AsSlice<T> for [T]
impl<'a, T> Default for &'a [T]
impl<'a, T> IntoIterator for &'a [T]
impl<'a, T> IntoIterator for &'a mut [T]
impl MutableByteVector for [u8]
fn set_memory(&mut self, value: u8)
impl<A, B> PartialEq<[B]> for [A] where A: PartialEq<B>
impl<T> Eq for [T] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> Ord for [T] where T: Ord
impl<T> PartialOrd<[T]> for [T] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T]) -> Option<Ordering>
fn lt(&self, other: &[T]) -> bool
fn le(&self, other: &[T]) -> bool
fn ge(&self, other: &[T]) -> bool
fn gt(&self, other: &[T]) -> bool
fn lt(&self, &[T]) -> bool
fn le(&self, &[T]) -> bool
fn gt(&self, &[T]) -> bool
fn ge(&self, &[T]) -> bool
impl IntSliceExt<u8, i8> for [u8]
fn as_unsigned(&self) -> &[u8]
fn as_signed(&self) -> &[i8]
fn as_unsigned_mut(&mut self) -> &mut [u8]
fn as_signed_mut(&mut self) -> &mut [i8]
impl IntSliceExt<u8, i8> for [i8]
fn as_unsigned(&self) -> &[u8]
fn as_signed(&self) -> &[i8]
fn as_unsigned_mut(&mut self) -> &mut [u8]
fn as_signed_mut(&mut self) -> &mut [i8]
impl IntSliceExt<u16, i16> for [u16]
fn as_unsigned(&self) -> &[u16]
fn as_signed(&self) -> &[i16]
fn as_unsigned_mut(&mut self) -> &mut [u16]
fn as_signed_mut(&mut self) -> &mut [i16]
impl IntSliceExt<u16, i16> for [i16]
fn as_unsigned(&self) -> &[u16]
fn as_signed(&self) -> &[i16]
fn as_unsigned_mut(&mut self) -> &mut [u16]
fn as_signed_mut(&mut self) -> &mut [i16]
impl IntSliceExt<u32, i32> for [u32]
fn as_unsigned(&self) -> &[u32]
fn as_signed(&self) -> &[i32]
fn as_unsigned_mut(&mut self) -> &mut [u32]
fn as_signed_mut(&mut self) -> &mut [i32]
impl IntSliceExt<u32, i32> for [i32]
fn as_unsigned(&self) -> &[u32]
fn as_signed(&self) -> &[i32]
fn as_unsigned_mut(&mut self) -> &mut [u32]
fn as_signed_mut(&mut self) -> &mut [i32]
impl IntSliceExt<u64, i64> for [u64]
fn as_unsigned(&self) -> &[u64]
fn as_signed(&self) -> &[i64]
fn as_unsigned_mut(&mut self) -> &mut [u64]
fn as_signed_mut(&mut self) -> &mut [i64]
impl IntSliceExt<u64, i64> for [i64]
fn as_unsigned(&self) -> &[u64]
fn as_signed(&self) -> &[i64]
fn as_unsigned_mut(&mut self) -> &mut [u64]
fn as_signed_mut(&mut self) -> &mut [i64]
impl IntSliceExt<usize, isize> for [usize]
fn as_unsigned(&self) -> &[usize]
fn as_signed(&self) -> &[isize]
fn as_unsigned_mut(&mut self) -> &mut [usize]
fn as_signed_mut(&mut self) -> &mut [isize]
impl IntSliceExt<usize, isize> for [isize]
fn as_unsigned(&self) -> &[usize]
fn as_signed(&self) -> &[isize]
fn as_unsigned_mut(&mut self) -> &mut [usize]
fn as_signed_mut(&mut self) -> &mut [isize]
impl<'a> CharEq for &'a [char]
fn matches(&mut self, c: char) -> bool
fn only_ascii(&self) -> bool
impl<T> Hash for [T] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T]], &mut H) where H: Hasher, [T]: Sized
impl<T> Debug for [T] where T: Debug
impl<T> Clone for [T; 0] where T: Copy
fn clone(&self) -> [T; 0]
fn clone_from(&mut self, &[T; 0])
impl<T> Hash for [T; 0] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 0]], &mut H) where H: Hasher, [T; 0]: Sized
impl<T> Debug for [T; 0] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 0]
impl<'a, T> IntoIterator for &'a mut [T; 0]
impl<A, B> PartialEq<[B; 0]> for [A; 0] where A: PartialEq<B>
fn eq(&self, other: &[B; 0]) -> bool
fn ne(&self, other: &[B; 0]) -> bool
fn ne(&self, &[B; 0]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 0] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 0] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 0]> for [T; 0] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 0]) -> Option<Ordering>
fn lt(&self, other: &[T; 0]) -> bool
fn le(&self, other: &[T; 0]) -> bool
fn ge(&self, other: &[T; 0]) -> bool
fn gt(&self, other: &[T; 0]) -> bool
fn lt(&self, &[T; 0]) -> bool
fn le(&self, &[T; 0]) -> bool
fn gt(&self, &[T; 0]) -> bool
fn ge(&self, &[T; 0]) -> bool
impl<T> Ord for [T; 0] where T: Ord
impl<T> Clone for [T; 1] where T: Copy
fn clone(&self) -> [T; 1]
fn clone_from(&mut self, &[T; 1])
impl<T> Hash for [T; 1] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 1]], &mut H) where H: Hasher, [T; 1]: Sized
impl<T> Debug for [T; 1] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 1]
impl<'a, T> IntoIterator for &'a mut [T; 1]
impl<A, B> PartialEq<[B; 1]> for [A; 1] where A: PartialEq<B>
fn eq(&self, other: &[B; 1]) -> bool
fn ne(&self, other: &[B; 1]) -> bool
fn ne(&self, &[B; 1]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 1] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 1] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 1]> for [T; 1] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 1]) -> Option<Ordering>
fn lt(&self, other: &[T; 1]) -> bool
fn le(&self, other: &[T; 1]) -> bool
fn ge(&self, other: &[T; 1]) -> bool
fn gt(&self, other: &[T; 1]) -> bool
fn lt(&self, &[T; 1]) -> bool
fn le(&self, &[T; 1]) -> bool
fn gt(&self, &[T; 1]) -> bool
fn ge(&self, &[T; 1]) -> bool
impl<T> Ord for [T; 1] where T: Ord
impl<T> Clone for [T; 2] where T: Copy
fn clone(&self) -> [T; 2]
fn clone_from(&mut self, &[T; 2])
impl<T> Hash for [T; 2] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 2]], &mut H) where H: Hasher, [T; 2]: Sized
impl<T> Debug for [T; 2] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 2]
impl<'a, T> IntoIterator for &'a mut [T; 2]
impl<A, B> PartialEq<[B; 2]> for [A; 2] where A: PartialEq<B>
fn eq(&self, other: &[B; 2]) -> bool
fn ne(&self, other: &[B; 2]) -> bool
fn ne(&self, &[B; 2]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 2] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 2] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 2]> for [T; 2] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 2]) -> Option<Ordering>
fn lt(&self, other: &[T; 2]) -> bool
fn le(&self, other: &[T; 2]) -> bool
fn ge(&self, other: &[T; 2]) -> bool
fn gt(&self, other: &[T; 2]) -> bool
fn lt(&self, &[T; 2]) -> bool
fn le(&self, &[T; 2]) -> bool
fn gt(&self, &[T; 2]) -> bool
fn ge(&self, &[T; 2]) -> bool
impl<T> Ord for [T; 2] where T: Ord
impl<T> Clone for [T; 3] where T: Copy
fn clone(&self) -> [T; 3]
fn clone_from(&mut self, &[T; 3])
impl<T> Hash for [T; 3] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 3]], &mut H) where H: Hasher, [T; 3]: Sized
impl<T> Debug for [T; 3] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 3]
impl<'a, T> IntoIterator for &'a mut [T; 3]
impl<A, B> PartialEq<[B; 3]> for [A; 3] where A: PartialEq<B>
fn eq(&self, other: &[B; 3]) -> bool
fn ne(&self, other: &[B; 3]) -> bool
fn ne(&self, &[B; 3]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 3] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 3] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 3]> for [T; 3] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 3]) -> Option<Ordering>
fn lt(&self, other: &[T; 3]) -> bool
fn le(&self, other: &[T; 3]) -> bool
fn ge(&self, other: &[T; 3]) -> bool
fn gt(&self, other: &[T; 3]) -> bool
fn lt(&self, &[T; 3]) -> bool
fn le(&self, &[T; 3]) -> bool
fn gt(&self, &[T; 3]) -> bool
fn ge(&self, &[T; 3]) -> bool
impl<T> Ord for [T; 3] where T: Ord
impl<T> Clone for [T; 4] where T: Copy
fn clone(&self) -> [T; 4]
fn clone_from(&mut self, &[T; 4])
impl<T> Hash for [T; 4] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 4]], &mut H) where H: Hasher, [T; 4]: Sized
impl<T> Debug for [T; 4] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 4]
impl<'a, T> IntoIterator for &'a mut [T; 4]
impl<A, B> PartialEq<[B; 4]> for [A; 4] where A: PartialEq<B>
fn eq(&self, other: &[B; 4]) -> bool
fn ne(&self, other: &[B; 4]) -> bool
fn ne(&self, &[B; 4]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 4] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 4] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 4]> for [T; 4] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 4]) -> Option<Ordering>
fn lt(&self, other: &[T; 4]) -> bool
fn le(&self, other: &[T; 4]) -> bool
fn ge(&self, other: &[T; 4]) -> bool
fn gt(&self, other: &[T; 4]) -> bool
fn lt(&self, &[T; 4]) -> bool
fn le(&self, &[T; 4]) -> bool
fn gt(&self, &[T; 4]) -> bool
fn ge(&self, &[T; 4]) -> bool
impl<T> Ord for [T; 4] where T: Ord
impl<T> Clone for [T; 5] where T: Copy
fn clone(&self) -> [T; 5]
fn clone_from(&mut self, &[T; 5])
impl<T> Hash for [T; 5] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 5]], &mut H) where H: Hasher, [T; 5]: Sized
impl<T> Debug for [T; 5] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 5]
impl<'a, T> IntoIterator for &'a mut [T; 5]
impl<A, B> PartialEq<[B; 5]> for [A; 5] where A: PartialEq<B>
fn eq(&self, other: &[B; 5]) -> bool
fn ne(&self, other: &[B; 5]) -> bool
fn ne(&self, &[B; 5]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 5] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 5] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 5]> for [T; 5] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 5]) -> Option<Ordering>
fn lt(&self, other: &[T; 5]) -> bool
fn le(&self, other: &[T; 5]) -> bool
fn ge(&self, other: &[T; 5]) -> bool
fn gt(&self, other: &[T; 5]) -> bool
fn lt(&self, &[T; 5]) -> bool
fn le(&self, &[T; 5]) -> bool
fn gt(&self, &[T; 5]) -> bool
fn ge(&self, &[T; 5]) -> bool
impl<T> Ord for [T; 5] where T: Ord
impl<T> Clone for [T; 6] where T: Copy
fn clone(&self) -> [T; 6]
fn clone_from(&mut self, &[T; 6])
impl<T> Hash for [T; 6] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 6]], &mut H) where H: Hasher, [T; 6]: Sized
impl<T> Debug for [T; 6] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 6]
impl<'a, T> IntoIterator for &'a mut [T; 6]
impl<A, B> PartialEq<[B; 6]> for [A; 6] where A: PartialEq<B>
fn eq(&self, other: &[B; 6]) -> bool
fn ne(&self, other: &[B; 6]) -> bool
fn ne(&self, &[B; 6]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 6] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 6] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 6]> for [T; 6] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 6]) -> Option<Ordering>
fn lt(&self, other: &[T; 6]) -> bool
fn le(&self, other: &[T; 6]) -> bool
fn ge(&self, other: &[T; 6]) -> bool
fn gt(&self, other: &[T; 6]) -> bool
fn lt(&self, &[T; 6]) -> bool
fn le(&self, &[T; 6]) -> bool
fn gt(&self, &[T; 6]) -> bool
fn ge(&self, &[T; 6]) -> bool
impl<T> Ord for [T; 6] where T: Ord
impl<T> Clone for [T; 7] where T: Copy
fn clone(&self) -> [T; 7]
fn clone_from(&mut self, &[T; 7])
impl<T> Hash for [T; 7] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 7]], &mut H) where H: Hasher, [T; 7]: Sized
impl<T> Debug for [T; 7] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 7]
impl<'a, T> IntoIterator for &'a mut [T; 7]
impl<A, B> PartialEq<[B; 7]> for [A; 7] where A: PartialEq<B>
fn eq(&self, other: &[B; 7]) -> bool
fn ne(&self, other: &[B; 7]) -> bool
fn ne(&self, &[B; 7]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 7] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 7] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 7]> for [T; 7] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 7]) -> Option<Ordering>
fn lt(&self, other: &[T; 7]) -> bool
fn le(&self, other: &[T; 7]) -> bool
fn ge(&self, other: &[T; 7]) -> bool
fn gt(&self, other: &[T; 7]) -> bool
fn lt(&self, &[T; 7]) -> bool
fn le(&self, &[T; 7]) -> bool
fn gt(&self, &[T; 7]) -> bool
fn ge(&self, &[T; 7]) -> bool
impl<T> Ord for [T; 7] where T: Ord
impl<T> Clone for [T; 8] where T: Copy
fn clone(&self) -> [T; 8]
fn clone_from(&mut self, &[T; 8])
impl<T> Hash for [T; 8] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 8]], &mut H) where H: Hasher, [T; 8]: Sized
impl<T> Debug for [T; 8] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 8]
impl<'a, T> IntoIterator for &'a mut [T; 8]
impl<A, B> PartialEq<[B; 8]> for [A; 8] where A: PartialEq<B>
fn eq(&self, other: &[B; 8]) -> bool
fn ne(&self, other: &[B; 8]) -> bool
fn ne(&self, &[B; 8]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 8] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 8] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 8]> for [T; 8] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 8]) -> Option<Ordering>
fn lt(&self, other: &[T; 8]) -> bool
fn le(&self, other: &[T; 8]) -> bool
fn ge(&self, other: &[T; 8]) -> bool
fn gt(&self, other: &[T; 8]) -> bool
fn lt(&self, &[T; 8]) -> bool
fn le(&self, &[T; 8]) -> bool
fn gt(&self, &[T; 8]) -> bool
fn ge(&self, &[T; 8]) -> bool
impl<T> Ord for [T; 8] where T: Ord
impl<T> Clone for [T; 9] where T: Copy
fn clone(&self) -> [T; 9]
fn clone_from(&mut self, &[T; 9])
impl<T> Hash for [T; 9] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 9]], &mut H) where H: Hasher, [T; 9]: Sized
impl<T> Debug for [T; 9] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 9]
impl<'a, T> IntoIterator for &'a mut [T; 9]
impl<A, B> PartialEq<[B; 9]> for [A; 9] where A: PartialEq<B>
fn eq(&self, other: &[B; 9]) -> bool
fn ne(&self, other: &[B; 9]) -> bool
fn ne(&self, &[B; 9]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 9] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 9] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 9]> for [T; 9] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 9]) -> Option<Ordering>
fn lt(&self, other: &[T; 9]) -> bool
fn le(&self, other: &[T; 9]) -> bool
fn ge(&self, other: &[T; 9]) -> bool
fn gt(&self, other: &[T; 9]) -> bool
fn lt(&self, &[T; 9]) -> bool
fn le(&self, &[T; 9]) -> bool
fn gt(&self, &[T; 9]) -> bool
fn ge(&self, &[T; 9]) -> bool
impl<T> Ord for [T; 9] where T: Ord
impl<T> Clone for [T; 10] where T: Copy
fn clone(&self) -> [T; 10]
fn clone_from(&mut self, &[T; 10])
impl<T> Hash for [T; 10] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 10]], &mut H) where H: Hasher, [T; 10]: Sized
impl<T> Debug for [T; 10] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 10]
impl<'a, T> IntoIterator for &'a mut [T; 10]
impl<A, B> PartialEq<[B; 10]> for [A; 10] where A: PartialEq<B>
fn eq(&self, other: &[B; 10]) -> bool
fn ne(&self, other: &[B; 10]) -> bool
fn ne(&self, &[B; 10]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 10] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 10] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 10]> for [T; 10] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 10]) -> Option<Ordering>
fn lt(&self, other: &[T; 10]) -> bool
fn le(&self, other: &[T; 10]) -> bool
fn ge(&self, other: &[T; 10]) -> bool
fn gt(&self, other: &[T; 10]) -> bool
fn lt(&self, &[T; 10]) -> bool
fn le(&self, &[T; 10]) -> bool
fn gt(&self, &[T; 10]) -> bool
fn ge(&self, &[T; 10]) -> bool
impl<T> Ord for [T; 10] where T: Ord
impl<T> Clone for [T; 11] where T: Copy
fn clone(&self) -> [T; 11]
fn clone_from(&mut self, &[T; 11])
impl<T> Hash for [T; 11] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 11]], &mut H) where H: Hasher, [T; 11]: Sized
impl<T> Debug for [T; 11] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 11]
impl<'a, T> IntoIterator for &'a mut [T; 11]
impl<A, B> PartialEq<[B; 11]> for [A; 11] where A: PartialEq<B>
fn eq(&self, other: &[B; 11]) -> bool
fn ne(&self, other: &[B; 11]) -> bool
fn ne(&self, &[B; 11]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 11] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 11] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 11]> for [T; 11] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 11]) -> Option<Ordering>
fn lt(&self, other: &[T; 11]) -> bool
fn le(&self, other: &[T; 11]) -> bool
fn ge(&self, other: &[T; 11]) -> bool
fn gt(&self, other: &[T; 11]) -> bool
fn lt(&self, &[T; 11]) -> bool
fn le(&self, &[T; 11]) -> bool
fn gt(&self, &[T; 11]) -> bool
fn ge(&self, &[T; 11]) -> bool
impl<T> Ord for [T; 11] where T: Ord
impl<T> Clone for [T; 12] where T: Copy
fn clone(&self) -> [T; 12]
fn clone_from(&mut self, &[T; 12])
impl<T> Hash for [T; 12] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 12]], &mut H) where H: Hasher, [T; 12]: Sized
impl<T> Debug for [T; 12] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 12]
impl<'a, T> IntoIterator for &'a mut [T; 12]
impl<A, B> PartialEq<[B; 12]> for [A; 12] where A: PartialEq<B>
fn eq(&self, other: &[B; 12]) -> bool
fn ne(&self, other: &[B; 12]) -> bool
fn ne(&self, &[B; 12]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 12] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 12] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 12]> for [T; 12] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 12]) -> Option<Ordering>
fn lt(&self, other: &[T; 12]) -> bool
fn le(&self, other: &[T; 12]) -> bool
fn ge(&self, other: &[T; 12]) -> bool
fn gt(&self, other: &[T; 12]) -> bool
fn lt(&self, &[T; 12]) -> bool
fn le(&self, &[T; 12]) -> bool
fn gt(&self, &[T; 12]) -> bool
fn ge(&self, &[T; 12]) -> bool
impl<T> Ord for [T; 12] where T: Ord
impl<T> Clone for [T; 13] where T: Copy
fn clone(&self) -> [T; 13]
fn clone_from(&mut self, &[T; 13])
impl<T> Hash for [T; 13] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 13]], &mut H) where H: Hasher, [T; 13]: Sized
impl<T> Debug for [T; 13] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 13]
impl<'a, T> IntoIterator for &'a mut [T; 13]
impl<A, B> PartialEq<[B; 13]> for [A; 13] where A: PartialEq<B>
fn eq(&self, other: &[B; 13]) -> bool
fn ne(&self, other: &[B; 13]) -> bool
fn ne(&self, &[B; 13]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 13] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 13] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 13]> for [T; 13] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 13]) -> Option<Ordering>
fn lt(&self, other: &[T; 13]) -> bool
fn le(&self, other: &[T; 13]) -> bool
fn ge(&self, other: &[T; 13]) -> bool
fn gt(&self, other: &[T; 13]) -> bool
fn lt(&self, &[T; 13]) -> bool
fn le(&self, &[T; 13]) -> bool
fn gt(&self, &[T; 13]) -> bool
fn ge(&self, &[T; 13]) -> bool
impl<T> Ord for [T; 13] where T: Ord
impl<T> Clone for [T; 14] where T: Copy
fn clone(&self) -> [T; 14]
fn clone_from(&mut self, &[T; 14])
impl<T> Hash for [T; 14] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 14]], &mut H) where H: Hasher, [T; 14]: Sized
impl<T> Debug for [T; 14] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 14]
impl<'a, T> IntoIterator for &'a mut [T; 14]
impl<A, B> PartialEq<[B; 14]> for [A; 14] where A: PartialEq<B>
fn eq(&self, other: &[B; 14]) -> bool
fn ne(&self, other: &[B; 14]) -> bool
fn ne(&self, &[B; 14]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 14] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 14] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 14]> for [T; 14] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 14]) -> Option<Ordering>
fn lt(&self, other: &[T; 14]) -> bool
fn le(&self, other: &[T; 14]) -> bool
fn ge(&self, other: &[T; 14]) -> bool
fn gt(&self, other: &[T; 14]) -> bool
fn lt(&self, &[T; 14]) -> bool
fn le(&self, &[T; 14]) -> bool
fn gt(&self, &[T; 14]) -> bool
fn ge(&self, &[T; 14]) -> bool
impl<T> Ord for [T; 14] where T: Ord
impl<T> Clone for [T; 15] where T: Copy
fn clone(&self) -> [T; 15]
fn clone_from(&mut self, &[T; 15])
impl<T> Hash for [T; 15] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 15]], &mut H) where H: Hasher, [T; 15]: Sized
impl<T> Debug for [T; 15] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 15]
impl<'a, T> IntoIterator for &'a mut [T; 15]
impl<A, B> PartialEq<[B; 15]> for [A; 15] where A: PartialEq<B>
fn eq(&self, other: &[B; 15]) -> bool
fn ne(&self, other: &[B; 15]) -> bool
fn ne(&self, &[B; 15]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 15] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 15] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 15]> for [T; 15] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 15]) -> Option<Ordering>
fn lt(&self, other: &[T; 15]) -> bool
fn le(&self, other: &[T; 15]) -> bool
fn ge(&self, other: &[T; 15]) -> bool
fn gt(&self, other: &[T; 15]) -> bool
fn lt(&self, &[T; 15]) -> bool
fn le(&self, &[T; 15]) -> bool
fn gt(&self, &[T; 15]) -> bool
fn ge(&self, &[T; 15]) -> bool
impl<T> Ord for [T; 15] where T: Ord
impl<T> Clone for [T; 16] where T: Copy
fn clone(&self) -> [T; 16]
fn clone_from(&mut self, &[T; 16])
impl<T> Hash for [T; 16] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 16]], &mut H) where H: Hasher, [T; 16]: Sized
impl<T> Debug for [T; 16] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 16]
impl<'a, T> IntoIterator for &'a mut [T; 16]
impl<A, B> PartialEq<[B; 16]> for [A; 16] where A: PartialEq<B>
fn eq(&self, other: &[B; 16]) -> bool
fn ne(&self, other: &[B; 16]) -> bool
fn ne(&self, &[B; 16]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 16] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 16] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 16]> for [T; 16] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 16]) -> Option<Ordering>
fn lt(&self, other: &[T; 16]) -> bool
fn le(&self, other: &[T; 16]) -> bool
fn ge(&self, other: &[T; 16]) -> bool
fn gt(&self, other: &[T; 16]) -> bool
fn lt(&self, &[T; 16]) -> bool
fn le(&self, &[T; 16]) -> bool
fn gt(&self, &[T; 16]) -> bool
fn ge(&self, &[T; 16]) -> bool
impl<T> Ord for [T; 16] where T: Ord
impl<T> Clone for [T; 17] where T: Copy
fn clone(&self) -> [T; 17]
fn clone_from(&mut self, &[T; 17])
impl<T> Hash for [T; 17] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 17]], &mut H) where H: Hasher, [T; 17]: Sized
impl<T> Debug for [T; 17] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 17]
impl<'a, T> IntoIterator for &'a mut [T; 17]
impl<A, B> PartialEq<[B; 17]> for [A; 17] where A: PartialEq<B>
fn eq(&self, other: &[B; 17]) -> bool
fn ne(&self, other: &[B; 17]) -> bool
fn ne(&self, &[B; 17]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 17] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 17] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 17]> for [T; 17] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 17]) -> Option<Ordering>
fn lt(&self, other: &[T; 17]) -> bool
fn le(&self, other: &[T; 17]) -> bool
fn ge(&self, other: &[T; 17]) -> bool
fn gt(&self, other: &[T; 17]) -> bool
fn lt(&self, &[T; 17]) -> bool
fn le(&self, &[T; 17]) -> bool
fn gt(&self, &[T; 17]) -> bool
fn ge(&self, &[T; 17]) -> bool
impl<T> Ord for [T; 17] where T: Ord
impl<T> Clone for [T; 18] where T: Copy
fn clone(&self) -> [T; 18]
fn clone_from(&mut self, &[T; 18])
impl<T> Hash for [T; 18] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 18]], &mut H) where H: Hasher, [T; 18]: Sized
impl<T> Debug for [T; 18] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 18]
impl<'a, T> IntoIterator for &'a mut [T; 18]
impl<A, B> PartialEq<[B; 18]> for [A; 18] where A: PartialEq<B>
fn eq(&self, other: &[B; 18]) -> bool
fn ne(&self, other: &[B; 18]) -> bool
fn ne(&self, &[B; 18]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 18] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 18] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 18]> for [T; 18] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 18]) -> Option<Ordering>
fn lt(&self, other: &[T; 18]) -> bool
fn le(&self, other: &[T; 18]) -> bool
fn ge(&self, other: &[T; 18]) -> bool
fn gt(&self, other: &[T; 18]) -> bool
fn lt(&self, &[T; 18]) -> bool
fn le(&self, &[T; 18]) -> bool
fn gt(&self, &[T; 18]) -> bool
fn ge(&self, &[T; 18]) -> bool
impl<T> Ord for [T; 18] where T: Ord
impl<T> Clone for [T; 19] where T: Copy
fn clone(&self) -> [T; 19]
fn clone_from(&mut self, &[T; 19])
impl<T> Hash for [T; 19] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 19]], &mut H) where H: Hasher, [T; 19]: Sized
impl<T> Debug for [T; 19] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 19]
impl<'a, T> IntoIterator for &'a mut [T; 19]
impl<A, B> PartialEq<[B; 19]> for [A; 19] where A: PartialEq<B>
fn eq(&self, other: &[B; 19]) -> bool
fn ne(&self, other: &[B; 19]) -> bool
fn ne(&self, &[B; 19]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 19] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 19] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 19]> for [T; 19] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 19]) -> Option<Ordering>
fn lt(&self, other: &[T; 19]) -> bool
fn le(&self, other: &[T; 19]) -> bool
fn ge(&self, other: &[T; 19]) -> bool
fn gt(&self, other: &[T; 19]) -> bool
fn lt(&self, &[T; 19]) -> bool
fn le(&self, &[T; 19]) -> bool
fn gt(&self, &[T; 19]) -> bool
fn ge(&self, &[T; 19]) -> bool
impl<T> Ord for [T; 19] where T: Ord
impl<T> Clone for [T; 20] where T: Copy
fn clone(&self) -> [T; 20]
fn clone_from(&mut self, &[T; 20])
impl<T> Hash for [T; 20] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 20]], &mut H) where H: Hasher, [T; 20]: Sized
impl<T> Debug for [T; 20] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 20]
impl<'a, T> IntoIterator for &'a mut [T; 20]
impl<A, B> PartialEq<[B; 20]> for [A; 20] where A: PartialEq<B>
fn eq(&self, other: &[B; 20]) -> bool
fn ne(&self, other: &[B; 20]) -> bool
fn ne(&self, &[B; 20]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 20] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 20] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 20]> for [T; 20] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 20]) -> Option<Ordering>
fn lt(&self, other: &[T; 20]) -> bool
fn le(&self, other: &[T; 20]) -> bool
fn ge(&self, other: &[T; 20]) -> bool
fn gt(&self, other: &[T; 20]) -> bool
fn lt(&self, &[T; 20]) -> bool
fn le(&self, &[T; 20]) -> bool
fn gt(&self, &[T; 20]) -> bool
fn ge(&self, &[T; 20]) -> bool
impl<T> Ord for [T; 20] where T: Ord
impl<T> Clone for [T; 21] where T: Copy
fn clone(&self) -> [T; 21]
fn clone_from(&mut self, &[T; 21])
impl<T> Hash for [T; 21] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 21]], &mut H) where H: Hasher, [T; 21]: Sized
impl<T> Debug for [T; 21] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 21]
impl<'a, T> IntoIterator for &'a mut [T; 21]
impl<A, B> PartialEq<[B; 21]> for [A; 21] where A: PartialEq<B>
fn eq(&self, other: &[B; 21]) -> bool
fn ne(&self, other: &[B; 21]) -> bool
fn ne(&self, &[B; 21]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 21] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 21] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 21]> for [T; 21] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 21]) -> Option<Ordering>
fn lt(&self, other: &[T; 21]) -> bool
fn le(&self, other: &[T; 21]) -> bool
fn ge(&self, other: &[T; 21]) -> bool
fn gt(&self, other: &[T; 21]) -> bool
fn lt(&self, &[T; 21]) -> bool
fn le(&self, &[T; 21]) -> bool
fn gt(&self, &[T; 21]) -> bool
fn ge(&self, &[T; 21]) -> bool
impl<T> Ord for [T; 21] where T: Ord
impl<T> Clone for [T; 22] where T: Copy
fn clone(&self) -> [T; 22]
fn clone_from(&mut self, &[T; 22])
impl<T> Hash for [T; 22] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 22]], &mut H) where H: Hasher, [T; 22]: Sized
impl<T> Debug for [T; 22] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 22]
impl<'a, T> IntoIterator for &'a mut [T; 22]
impl<A, B> PartialEq<[B; 22]> for [A; 22] where A: PartialEq<B>
fn eq(&self, other: &[B; 22]) -> bool
fn ne(&self, other: &[B; 22]) -> bool
fn ne(&self, &[B; 22]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 22] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 22] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 22]> for [T; 22] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 22]) -> Option<Ordering>
fn lt(&self, other: &[T; 22]) -> bool
fn le(&self, other: &[T; 22]) -> bool
fn ge(&self, other: &[T; 22]) -> bool
fn gt(&self, other: &[T; 22]) -> bool
fn lt(&self, &[T; 22]) -> bool
fn le(&self, &[T; 22]) -> bool
fn gt(&self, &[T; 22]) -> bool
fn ge(&self, &[T; 22]) -> bool
impl<T> Ord for [T; 22] where T: Ord
impl<T> Clone for [T; 23] where T: Copy
fn clone(&self) -> [T; 23]
fn clone_from(&mut self, &[T; 23])
impl<T> Hash for [T; 23] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 23]], &mut H) where H: Hasher, [T; 23]: Sized
impl<T> Debug for [T; 23] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 23]
impl<'a, T> IntoIterator for &'a mut [T; 23]
impl<A, B> PartialEq<[B; 23]> for [A; 23] where A: PartialEq<B>
fn eq(&self, other: &[B; 23]) -> bool
fn ne(&self, other: &[B; 23]) -> bool
fn ne(&self, &[B; 23]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 23] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 23] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 23]> for [T; 23] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 23]) -> Option<Ordering>
fn lt(&self, other: &[T; 23]) -> bool
fn le(&self, other: &[T; 23]) -> bool
fn ge(&self, other: &[T; 23]) -> bool
fn gt(&self, other: &[T; 23]) -> bool
fn lt(&self, &[T; 23]) -> bool
fn le(&self, &[T; 23]) -> bool
fn gt(&self, &[T; 23]) -> bool
fn ge(&self, &[T; 23]) -> bool
impl<T> Ord for [T; 23] where T: Ord
impl<T> Clone for [T; 24] where T: Copy
fn clone(&self) -> [T; 24]
fn clone_from(&mut self, &[T; 24])
impl<T> Hash for [T; 24] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 24]], &mut H) where H: Hasher, [T; 24]: Sized
impl<T> Debug for [T; 24] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 24]
impl<'a, T> IntoIterator for &'a mut [T; 24]
impl<A, B> PartialEq<[B; 24]> for [A; 24] where A: PartialEq<B>
fn eq(&self, other: &[B; 24]) -> bool
fn ne(&self, other: &[B; 24]) -> bool
fn ne(&self, &[B; 24]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 24] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 24] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 24]> for [T; 24] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 24]) -> Option<Ordering>
fn lt(&self, other: &[T; 24]) -> bool
fn le(&self, other: &[T; 24]) -> bool
fn ge(&self, other: &[T; 24]) -> bool
fn gt(&self, other: &[T; 24]) -> bool
fn lt(&self, &[T; 24]) -> bool
fn le(&self, &[T; 24]) -> bool
fn gt(&self, &[T; 24]) -> bool
fn ge(&self, &[T; 24]) -> bool
impl<T> Ord for [T; 24] where T: Ord
impl<T> Clone for [T; 25] where T: Copy
fn clone(&self) -> [T; 25]
fn clone_from(&mut self, &[T; 25])
impl<T> Hash for [T; 25] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 25]], &mut H) where H: Hasher, [T; 25]: Sized
impl<T> Debug for [T; 25] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 25]
impl<'a, T> IntoIterator for &'a mut [T; 25]
impl<A, B> PartialEq<[B; 25]> for [A; 25] where A: PartialEq<B>
fn eq(&self, other: &[B; 25]) -> bool
fn ne(&self, other: &[B; 25]) -> bool
fn ne(&self, &[B; 25]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 25] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 25] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 25]> for [T; 25] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 25]) -> Option<Ordering>
fn lt(&self, other: &[T; 25]) -> bool
fn le(&self, other: &[T; 25]) -> bool
fn ge(&self, other: &[T; 25]) -> bool
fn gt(&self, other: &[T; 25]) -> bool
fn lt(&self, &[T; 25]) -> bool
fn le(&self, &[T; 25]) -> bool
fn gt(&self, &[T; 25]) -> bool
fn ge(&self, &[T; 25]) -> bool
impl<T> Ord for [T; 25] where T: Ord
impl<T> Clone for [T; 26] where T: Copy
fn clone(&self) -> [T; 26]
fn clone_from(&mut self, &[T; 26])
impl<T> Hash for [T; 26] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 26]], &mut H) where H: Hasher, [T; 26]: Sized
impl<T> Debug for [T; 26] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 26]
impl<'a, T> IntoIterator for &'a mut [T; 26]
impl<A, B> PartialEq<[B; 26]> for [A; 26] where A: PartialEq<B>
fn eq(&self, other: &[B; 26]) -> bool
fn ne(&self, other: &[B; 26]) -> bool
fn ne(&self, &[B; 26]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 26] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 26] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 26]> for [T; 26] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 26]) -> Option<Ordering>
fn lt(&self, other: &[T; 26]) -> bool
fn le(&self, other: &[T; 26]) -> bool
fn ge(&self, other: &[T; 26]) -> bool
fn gt(&self, other: &[T; 26]) -> bool
fn lt(&self, &[T; 26]) -> bool
fn le(&self, &[T; 26]) -> bool
fn gt(&self, &[T; 26]) -> bool
fn ge(&self, &[T; 26]) -> bool
impl<T> Ord for [T; 26] where T: Ord
impl<T> Clone for [T; 27] where T: Copy
fn clone(&self) -> [T; 27]
fn clone_from(&mut self, &[T; 27])
impl<T> Hash for [T; 27] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 27]], &mut H) where H: Hasher, [T; 27]: Sized
impl<T> Debug for [T; 27] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 27]
impl<'a, T> IntoIterator for &'a mut [T; 27]
impl<A, B> PartialEq<[B; 27]> for [A; 27] where A: PartialEq<B>
fn eq(&self, other: &[B; 27]) -> bool
fn ne(&self, other: &[B; 27]) -> bool
fn ne(&self, &[B; 27]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 27] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 27] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 27]> for [T; 27] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 27]) -> Option<Ordering>
fn lt(&self, other: &[T; 27]) -> bool
fn le(&self, other: &[T; 27]) -> bool
fn ge(&self, other: &[T; 27]) -> bool
fn gt(&self, other: &[T; 27]) -> bool
fn lt(&self, &[T; 27]) -> bool
fn le(&self, &[T; 27]) -> bool
fn gt(&self, &[T; 27]) -> bool
fn ge(&self, &[T; 27]) -> bool
impl<T> Ord for [T; 27] where T: Ord
impl<T> Clone for [T; 28] where T: Copy
fn clone(&self) -> [T; 28]
fn clone_from(&mut self, &[T; 28])
impl<T> Hash for [T; 28] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 28]], &mut H) where H: Hasher, [T; 28]: Sized
impl<T> Debug for [T; 28] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 28]
impl<'a, T> IntoIterator for &'a mut [T; 28]
impl<A, B> PartialEq<[B; 28]> for [A; 28] where A: PartialEq<B>
fn eq(&self, other: &[B; 28]) -> bool
fn ne(&self, other: &[B; 28]) -> bool
fn ne(&self, &[B; 28]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 28] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 28] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 28]> for [T; 28] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 28]) -> Option<Ordering>
fn lt(&self, other: &[T; 28]) -> bool
fn le(&self, other: &[T; 28]) -> bool
fn ge(&self, other: &[T; 28]) -> bool
fn gt(&self, other: &[T; 28]) -> bool
fn lt(&self, &[T; 28]) -> bool
fn le(&self, &[T; 28]) -> bool
fn gt(&self, &[T; 28]) -> bool
fn ge(&self, &[T; 28]) -> bool
impl<T> Ord for [T; 28] where T: Ord
impl<T> Clone for [T; 29] where T: Copy
fn clone(&self) -> [T; 29]
fn clone_from(&mut self, &[T; 29])
impl<T> Hash for [T; 29] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 29]], &mut H) where H: Hasher, [T; 29]: Sized
impl<T> Debug for [T; 29] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 29]
impl<'a, T> IntoIterator for &'a mut [T; 29]
impl<A, B> PartialEq<[B; 29]> for [A; 29] where A: PartialEq<B>
fn eq(&self, other: &[B; 29]) -> bool
fn ne(&self, other: &[B; 29]) -> bool
fn ne(&self, &[B; 29]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 29] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 29] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 29]> for [T; 29] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 29]) -> Option<Ordering>
fn lt(&self, other: &[T; 29]) -> bool
fn le(&self, other: &[T; 29]) -> bool
fn ge(&self, other: &[T; 29]) -> bool
fn gt(&self, other: &[T; 29]) -> bool
fn lt(&self, &[T; 29]) -> bool
fn le(&self, &[T; 29]) -> bool
fn gt(&self, &[T; 29]) -> bool
fn ge(&self, &[T; 29]) -> bool
impl<T> Ord for [T; 29] where T: Ord
impl<T> Clone for [T; 30] where T: Copy
fn clone(&self) -> [T; 30]
fn clone_from(&mut self, &[T; 30])
impl<T> Hash for [T; 30] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 30]], &mut H) where H: Hasher, [T; 30]: Sized
impl<T> Debug for [T; 30] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 30]
impl<'a, T> IntoIterator for &'a mut [T; 30]
impl<A, B> PartialEq<[B; 30]> for [A; 30] where A: PartialEq<B>
fn eq(&self, other: &[B; 30]) -> bool
fn ne(&self, other: &[B; 30]) -> bool
fn ne(&self, &[B; 30]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 30] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 30] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 30]> for [T; 30] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 30]) -> Option<Ordering>
fn lt(&self, other: &[T; 30]) -> bool
fn le(&self, other: &[T; 30]) -> bool
fn ge(&self, other: &[T; 30]) -> bool
fn gt(&self, other: &[T; 30]) -> bool
fn lt(&self, &[T; 30]) -> bool
fn le(&self, &[T; 30]) -> bool
fn gt(&self, &[T; 30]) -> bool
fn ge(&self, &[T; 30]) -> bool
impl<T> Ord for [T; 30] where T: Ord
impl<T> Clone for [T; 31] where T: Copy
fn clone(&self) -> [T; 31]
fn clone_from(&mut self, &[T; 31])
impl<T> Hash for [T; 31] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 31]], &mut H) where H: Hasher, [T; 31]: Sized
impl<T> Debug for [T; 31] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 31]
impl<'a, T> IntoIterator for &'a mut [T; 31]
impl<A, B> PartialEq<[B; 31]> for [A; 31] where A: PartialEq<B>
fn eq(&self, other: &[B; 31]) -> bool
fn ne(&self, other: &[B; 31]) -> bool
fn ne(&self, &[B; 31]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 31] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 31] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 31]> for [T; 31] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 31]) -> Option<Ordering>
fn lt(&self, other: &[T; 31]) -> bool
fn le(&self, other: &[T; 31]) -> bool
fn ge(&self, other: &[T; 31]) -> bool
fn gt(&self, other: &[T; 31]) -> bool
fn lt(&self, &[T; 31]) -> bool
fn le(&self, &[T; 31]) -> bool
fn gt(&self, &[T; 31]) -> bool
fn ge(&self, &[T; 31]) -> bool
impl<T> Ord for [T; 31] where T: Ord
impl<T> Clone for [T; 32] where T: Copy
fn clone(&self) -> [T; 32]
fn clone_from(&mut self, &[T; 32])
impl<T> Hash for [T; 32] where T: Hash
fn hash<H>(&self, state: &mut H) where H: Hasher
fn hash_slice<H>(&[[T; 32]], &mut H) where H: Hasher, [T; 32]: Sized
impl<T> Debug for [T; 32] where T: Debug
impl<'a, T> IntoIterator for &'a [T; 32]
impl<'a, T> IntoIterator for &'a mut [T; 32]
impl<A, B> PartialEq<[B; 32]> for [A; 32] where A: PartialEq<B>
fn eq(&self, other: &[B; 32]) -> bool
fn ne(&self, other: &[B; 32]) -> bool
fn ne(&self, &[B; 32]) -> bool
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; 32] where A: PartialEq<B>, Rhs: Deref, <Rhs as Deref>::Target == [B]
impl<T> Eq for [T; 32] where T: Eq
fn assert_receiver_is_total_eq(&self)
impl<T> PartialOrd<[T; 32]> for [T; 32] where T: PartialOrd<T>
fn partial_cmp(&self, other: &[T; 32]) -> Option<Ordering>
fn lt(&self, other: &[T; 32]) -> bool
fn le(&self, other: &[T; 32]) -> bool
fn ge(&self, other: &[T; 32]) -> bool
fn gt(&self, other: &[T; 32]) -> bool
fn lt(&self, &[T; 32]) -> bool
fn le(&self, &[T; 32]) -> bool
fn gt(&self, &[T; 32]) -> bool
fn ge(&self, &[T; 32]) -> bool
impl<T> Ord for [T; 32] where T: Ord
impl<T> SliceExt for [T]
type Item = T
fn sort_by<F>(&mut self, compare: F) where F: FnMut(&T, &T), <F as FnMut(&T, &T)>::Output == Ordering
fn move_from(&mut self, src: Vec<T>, start: usize, end: usize) -> usize
fn slice(&self, start: usize, end: usize) -> &[T]
fn slice_from(&self, start: usize) -> &[T]
fn slice_to(&self, end: usize) -> &[T]
fn split_at(&self, mid: usize) -> (&[T], &[T])
fn iter(&self) -> Iter<T>
fn split<F>(&self, pred: F) -> Split<T, F> where F: FnMut(&T), <F as FnMut(&T)>::Output == bool
fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F> where F: FnMut(&T), <F as FnMut(&T)>::Output == bool
fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F> where F: FnMut(&T), <F as FnMut(&T)>::Output == bool
fn windows(&self, size: usize) -> Windows<T>
fn chunks(&self, size: usize) -> Chunks<T>
fn get(&self, index: usize) -> Option<&T>
fn first(&self) -> Option<&T>
fn tail(&self) -> &[T]
fn init(&self) -> &[T]
fn last(&self) -> Option<&T>
unsafe fn get_unchecked(&self, index: usize) -> &T
fn as_ptr(&self) -> *const T
fn binary_search_by<F>(&self, f: F) -> Result<usize, usize> where F: FnMut(&T), <F as FnMut(&T)>::Output == Ordering
fn len(&self) -> usize
fn is_empty(&self) -> bool
fn get_mut(&mut self, index: usize) -> Option<&mut T>
fn as_mut_slice(&mut self) -> &mut [T]
fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T]
fn slice_from_mut(&mut self, start: usize) -> &mut [T]
fn slice_to_mut(&mut self, end: usize) -> &mut [T]
fn iter_mut(&mut self) -> IterMut<T>
fn first_mut(&mut self) -> Option<&mut T>
fn tail_mut(&mut self) -> &mut [T]
fn init_mut(&mut self) -> &mut [T]
fn last_mut(&mut self) -> Option<&mut T>
fn split_mut<F>(&mut self, pred: F) -> SplitMut<T, F> where F: FnMut(&T), <F as FnMut(&T)>::Output == bool
fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F> where F: FnMut(&T), <F as FnMut(&T)>::Output == bool
fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F> where F: FnMut(&T), <F as FnMut(&T)>::Output == bool
fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T>
fn swap(&mut self, a: usize, b: usize)
fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])
fn reverse(&mut self)
unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T
fn as_mut_ptr(&mut self) -> *mut T
fn to_vec(&self) -> Vec<T> where T: Clone
Returns a copy of v
.
fn permutations(&self) -> Permutations<T> where T: Clone
Returns an iterator over all permutations of a vector.