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.

fn main() { // 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"]; }
// 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:

fn main() { 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); }
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] }
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:

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.

fn main() { let numbers = [0, 1, 2]; for &x in numbers.iter() { println!("{} is a number!", x); } }
let numbers = [0, 1, 2];
for &x in numbers.iter() {
    println!("{} is a number!", x);
}

Trait Implementations

impl<T> Repr<Slice<T>> for [T]

fn repr(&self) -> Slice<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 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]

type Output = T

fn index(&self, &usize) -> &T

impl<T> IndexMut<usize> for [T]

fn index_mut(&mut self, &usize) -> &mut T

impl<T> Index<Range<usize>> for [T]

type Output = [T]

fn index(&self, index: &Range<usize>) -> &[T]

impl<T> Index<RangeTo<usize>> for [T]

type Output = [T]

fn index(&self, index: &RangeTo<usize>) -> &[T]

impl<T> Index<RangeFrom<usize>> for [T]

type Output = [T]

fn index(&self, index: &RangeFrom<usize>) -> &[T]

impl<T> Index<RangeFull> for [T]

type Output = [T]

fn index(&self, _index: &RangeFull) -> &[T]

impl<T> IndexMut<Range<usize>> for [T]

fn index_mut(&mut self, index: &Range<usize>) -> &mut [T]

impl<T> IndexMut<RangeTo<usize>> for [T]

fn index_mut(&mut self, index: &RangeTo<usize>) -> &mut [T]

impl<T> IndexMut<RangeFrom<usize>> for [T]

fn index_mut(&mut self, index: &RangeFrom<usize>) -> &mut [T]

impl<T> IndexMut<RangeFull> for [T]

fn index_mut(&mut self, _index: &RangeFull) -> &mut [T]

impl<T> AsSlice<T> for [T]

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

impl<'a, T> Default for &'a [T]

fn default() -> &'a [T]

impl<'a, T> IntoIterator for &'a [T]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

impl MutableByteVector for [u8]

fn set_memory(&mut self, value: u8)

impl<A, B> PartialEq<[B]> for [A] where A: PartialEq<B>

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

fn ne(&self, &[B]) -> bool

impl<T> Eq for [T] where T: Eq

fn assert_receiver_is_total_eq(&self)

impl<T> Ord for [T] where T: Ord

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 0]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 0]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 1]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 1]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 2]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 2]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 3]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 3]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 4]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 4]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 5]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 5]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 6]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 6]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 7]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 7]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 8]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 8]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 9]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 9]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 10]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 10]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 11]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 11]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 12]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 12]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 13]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 13]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 14]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 14]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 15]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 15]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 16]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 16]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 17]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 17]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 18]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 18]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 19]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 19]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 20]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 20]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 21]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 21]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 22]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 22]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 23]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 23]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 24]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 24]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 25]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 25]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 26]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 26]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 27]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 27]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 28]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 28]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 29]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 29]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 30]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 30]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 31]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 31]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> IntoIterator for &'a [T; 32]

type Item = &'a T

type IntoIter = Iter<'a, T>

fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut [T; 32]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'a, T>

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]

fn eq(&self, other: &Rhs) -> bool

fn ne(&self, other: &Rhs) -> bool

fn ne(&self, &Rhs) -> bool

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

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

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.

fn clone_from_slice(&mut self, src: &[T]) -> usize where T: Clone

fn sort(&mut self) where T: Ord

fn next_permutation(&mut self) -> bool where T: Ord

fn prev_permutation(&mut self) -> bool where T: Ord

fn position_elem(&self, t: &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 into_vec(self: Box<[T]>) -> Vec<T>

fn is_empty(&self) -> bool

fn binary_search_elem(&self, &<[T] as SliceExt>::Item) -> Result<usize, usize> where <[T] as SliceExt>::Item: Ord

impl<T, V> SliceConcatExt<T, Vec<T>> for [V] where T: Clone, V: AsSlice<T>

fn concat(&self) -> Vec<T>

fn connect(&self, sep: &T) -> Vec<T>

impl<T> ToOwned for [T] where T: Clone

type Owned = Vec<T>

fn to_owned(&self) -> Vec<T>

impl<S> SliceConcatExt<str, String> for [S] where S: Str

fn concat(&self) -> String

fn connect(&self, sep: &str) -> String

impl<'b, A, B> PartialEq<Vec<A>> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &Vec<A>) -> bool

fn ne(&self, other: &Vec<A>) -> bool

fn ne(&self, &Vec<A>) -> bool

impl<'b, A, B> PartialEq<Vec<A>> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &Vec<A>) -> bool

fn ne(&self, other: &Vec<A>) -> bool

fn ne(&self, &Vec<A>) -> bool

impl<'a, 'b, A, B> PartialEq<Cow<'a, [A]>> for &'b [B] where A: Clone, B: PartialEq<A>

fn eq(&self, other: &Cow<'a, [A]>) -> bool

fn ne(&self, other: &Cow<'a, [A]>) -> bool

fn ne(&self, &Cow<'a, [A]>) -> bool

impl<'a, 'b, A, B> PartialEq<Cow<'a, [A]>> for &'b mut [B] where A: Clone, B: PartialEq<A>

fn eq(&self, other: &Cow<'a, [A]>) -> bool

fn ne(&self, other: &Cow<'a, [A]>) -> bool

fn ne(&self, &Cow<'a, [A]>) -> bool

impl<'a, T> IntoCow<'a, [T]> for &'a [T] where T: Clone

fn into_cow(self) -> Cow<'a, [T]>

impl AsciiExt for [u8]

type Owned = Vec<u8>

fn is_ascii(&self) -> bool

fn to_ascii_uppercase(&self) -> Vec<u8>

fn to_ascii_lowercase(&self) -> Vec<u8>

fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool

fn make_ascii_uppercase(&mut self)

fn make_ascii_lowercase(&mut self)

impl<'a> IntoBytes for &'a [u8]

fn into_bytes(self) -> Vec<u8>

impl<'a> Reader for &'a [u8]

fn read(&mut self, buf: &mut [u8]) -> IoResult<usize>

fn read_at_least(&mut self, min: usize, buf: &mut [u8]) -> IoResult<usize>

fn read_byte(&mut self) -> IoResult<u8>

fn push(&mut self, len: usize, buf: &mut Vec<u8>) -> IoResult<usize>

fn push_at_least(&mut self, min: usize, len: usize, buf: &mut Vec<u8>) -> IoResult<usize>

fn read_exact(&mut self, len: usize) -> IoResult<Vec<u8>>

fn read_to_end(&mut self) -> IoResult<Vec<u8>>

fn read_to_string(&mut self) -> IoResult<String>

fn read_le_uint_n(&mut self, nbytes: usize) -> IoResult<u64>

fn read_le_int_n(&mut self, nbytes: usize) -> IoResult<i64>

fn read_be_uint_n(&mut self, nbytes: usize) -> IoResult<u64>

fn read_be_int_n(&mut self, nbytes: usize) -> IoResult<i64>

fn read_le_uint(&mut self) -> IoResult<usize>

fn read_le_int(&mut self) -> IoResult<isize>

fn read_be_uint(&mut self) -> IoResult<usize>

fn read_be_int(&mut self) -> IoResult<isize>

fn read_be_u64(&mut self) -> IoResult<u64>

fn read_be_u32(&mut self) -> IoResult<u32>

fn read_be_u16(&mut self) -> IoResult<u16>

fn read_be_i64(&mut self) -> IoResult<i64>

fn read_be_i32(&mut self) -> IoResult<i32>

fn read_be_i16(&mut self) -> IoResult<i16>

fn read_be_f64(&mut self) -> IoResult<f64>

fn read_be_f32(&mut self) -> IoResult<f32>

fn read_le_u64(&mut self) -> IoResult<u64>

fn read_le_u32(&mut self) -> IoResult<u32>

fn read_le_u16(&mut self) -> IoResult<u16>

fn read_le_i64(&mut self) -> IoResult<i64>

fn read_le_i32(&mut self) -> IoResult<i32>

fn read_le_i16(&mut self) -> IoResult<i16>

fn read_le_f64(&mut self) -> IoResult<f64>

fn read_le_f32(&mut self) -> IoResult<f32>

fn read_u8(&mut self) -> IoResult<u8>

fn read_i8(&mut self) -> IoResult<i8>

impl<'a> Buffer for &'a [u8]

fn fill_buf(&mut self) -> IoResult<&[u8]>

fn consume(&mut self, amt: usize)

fn read_line(&mut self) -> IoResult<String>

fn read_until(&mut self, byte: u8) -> IoResult<Vec<u8>>

fn read_char(&mut self) -> IoResult<char>

impl<'a> Read for &'a [u8]

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<()>

fn read_to_string(&mut self, buf: &mut String) -> Result<()>

impl<'a> BufRead for &'a [u8]

fn fill_buf(&mut self) -> Result<&[u8]>

fn consume(&mut self, amt: usize)

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<()>

fn read_line(&mut self, buf: &mut String) -> Result<()>

impl<'a> Write for &'a mut [u8]

fn write(&mut self, data: &[u8]) -> Result<usize>

fn flush(&mut self) -> Result<()>

fn write_all(&mut self, buf: &[u8]) -> Result<()>

fn write_fmt(&mut self, fmt: Arguments) -> Result<()>

impl BytesContainer for [u8]

fn container_as_bytes(&self) -> &[u8]

fn container_as_str<'a>(&'a self) -> Option<&'a str>

fn is_str(_: Option<&Self>) -> bool