std::array

Primitive Type array

A fixed-size array, denoted [T; N], for the element type, T, and the non-negative compile-time constant size, N.

There are two syntactic forms for creating an array:

• A list with each element, i.e. [x, y, z].
• A repeat expression [x; N], which produces an array with N copies of x. The type of x must be Copy.

Arrays of sizes from 0 to 32 (inclusive) implement the following traits if the element type allows it:

• Clone (only if T:Copy)
• Debug
• IntoIterator (implemented for &[T; N] and &mut [T; N])
• PartialEq, PartialOrd, Eq, Ord
• Hash
• AsRef, AsMut
• Borrow, BorrowMut
• Default

This limitation on the size N exists because Rust does not yet support code that is generic over the size of an array type. [Foo; 3] and [Bar; 3] are instances of same generic type [T; 3], but [Foo; 3] and [Foo; 5] are entirely different types. As a stopgap, trait implementations are statically generated up to size 32.

Arrays of any size are Copy if the element type is Copy. This works because the Copy trait is specially known to the compiler.

Arrays coerce to slices ([T]), so a slice method may be called on an array. Indeed, this provides most of the API for working with arrays. Slices have a dynamic size and do not coerce to arrays.

There is no way to move elements out of an array. See mem::replace for an alternative.

Examples

let mut array: [i32; 3] = [0; 3];

array[1] = 1;
array[2] = 2;

assert_eq!([1, 2], &array[1..]);

// This loop prints: 0 1 2
for x in &array {
    print!("{} ", x);
}

An array itself is not iterable:

let array: [i32; 3] = [0; 3];

for x in array { }
// error: the trait bound `[i32; 3]: std::iter::Iterator` is not satisfied

The solution is to coerce the array to a slice by calling a slice method:

for x in array.iter() { }

If the array has 32 or fewer elements (see above), you can also use the array reference's IntoIterator implementation:

for x in &array { }

Trait Implementations

impl<T> Eq for [T; 0] where
    T: Eq,  [src]

impl<T> Eq for [T; 1] where
    T: Eq,  [src]

impl<T> Eq for [T; 2] where
    T: Eq,  [src]

impl<T> Eq for [T; 3] where
    T: Eq,  [src]

impl<T> Eq for [T; 4] where
    T: Eq,  [src]

impl<T> Eq for [T; 5] where
    T: Eq,  [src]

impl<T> Eq for [T; 6] where
    T: Eq,  [src]

impl<T> Eq for [T; 7] where
    T: Eq,  [src]

impl<T> Eq for [T; 8] where
    T: Eq,  [src]

impl<T> Eq for [T; 9] where
    T: Eq,  [src]

impl<T> Eq for [T; 10] where
    T: Eq,  [src]

impl<T> Eq for [T; 11] where
    T: Eq,  [src]

impl<T> Eq for [T; 12] where
    T: Eq,  [src]

impl<T> Eq for [T; 13] where
    T: Eq,  [src]

impl<T> Eq for [T; 14] where
    T: Eq,  [src]

impl<T> Eq for [T; 15] where
    T: Eq,  [src]

impl<T> Eq for [T; 16] where
    T: Eq,  [src]

impl<T> Eq for [T; 17] where
    T: Eq,  [src]

impl<T> Eq for [T; 18] where
    T: Eq,  [src]

impl<T> Eq for [T; 19] where
    T: Eq,  [src]

impl<T> Eq for [T; 20] where
    T: Eq,  [src]

impl<T> Eq for [T; 21] where
    T: Eq,  [src]

impl<T> Eq for [T; 22] where
    T: Eq,  [src]

impl<T> Eq for [T; 23] where
    T: Eq,  [src]

impl<T> Eq for [T; 24] where
    T: Eq,  [src]

impl<T> Eq for [T; 25] where
    T: Eq,  [src]

impl<T> Eq for [T; 26] where
    T: Eq,  [src]

impl<T> Eq for [T; 27] where
    T: Eq,  [src]

impl<T> Eq for [T; 28] where
    T: Eq,  [src]

impl<T> Eq for [T; 29] where
    T: Eq,  [src]

impl<T> Eq for [T; 30] where
    T: Eq,  [src]

impl<T> Eq for [T; 31] where
    T: Eq,  [src]

impl<T> Eq for [T; 32] where
    T: Eq,  [src]

impl<T> Default for [T; 32] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 32]

impl<T> Default for [T; 31] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 31]

impl<T> Default for [T; 30] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 30]

impl<T> Default for [T; 29] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 29]

impl<T> Default for [T; 28] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 28]

impl<T> Default for [T; 27] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 27]

impl<T> Default for [T; 26] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 26]

impl<T> Default for [T; 25] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 25]

impl<T> Default for [T; 24] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 24]

impl<T> Default for [T; 23] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 23]

impl<T> Default for [T; 22] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 22]

impl<T> Default for [T; 21] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 21]

impl<T> Default for [T; 20] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 20]

impl<T> Default for [T; 19] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 19]

impl<T> Default for [T; 18] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 18]

impl<T> Default for [T; 17] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 17]

impl<T> Default for [T; 16] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 16]

impl<T> Default for [T; 15] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 15]

impl<T> Default for [T; 14] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 14]

impl<T> Default for [T; 13] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 13]

impl<T> Default for [T; 12] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 12]

impl<T> Default for [T; 11] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 11]

impl<T> Default for [T; 10] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 10]

impl<T> Default for [T; 9] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 9]

impl<T> Default for [T; 8] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 8]

impl<T> Default for [T; 7] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 7]

impl<T> Default for [T; 6] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 6]

impl<T> Default for [T; 5] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 5]

impl<T> Default for [T; 4] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 4]

impl<T> Default for [T; 3] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 3]

impl<T> Default for [T; 2] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 2]

impl<T> Default for [T; 1] where
    T: Default, 

1.4.0

[src]

fn default() -> [T; 1]

impl<T> Default for [T; 0]

1.4.0

[src]

fn default() -> [T; 0]

impl<T> AsMut<[T]> for [T; 0] [src]

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

impl<T> AsMut<[T]> for [T; 1] [src]

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

impl<T> AsMut<[T]> for [T; 2] [src]

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

impl<T> AsMut<[T]> for [T; 3] [src]

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

impl<T> AsMut<[T]> for [T; 4] [src]

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

impl<T> AsMut<[T]> for [T; 5] [src]

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

impl<T> AsMut<[T]> for [T; 6] [src]

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

impl<T> AsMut<[T]> for [T; 7] [src]

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

impl<T> AsMut<[T]> for [T; 8] [src]

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

impl<T> AsMut<[T]> for [T; 9] [src]

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

impl<T> AsMut<[T]> for [T; 10] [src]

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

impl<T> AsMut<[T]> for [T; 11] [src]

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

impl<T> AsMut<[T]> for [T; 12] [src]

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

impl<T> AsMut<[T]> for [T; 13] [src]

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

impl<T> AsMut<[T]> for [T; 14] [src]

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

impl<T> AsMut<[T]> for [T; 15] [src]

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

impl<T> AsMut<[T]> for [T; 16] [src]

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

impl<T> AsMut<[T]> for [T; 17] [src]

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

impl<T> AsMut<[T]> for [T; 18] [src]

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

impl<T> AsMut<[T]> for [T; 19] [src]

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

impl<T> AsMut<[T]> for [T; 20] [src]

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

impl<T> AsMut<[T]> for [T; 21] [src]

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

impl<T> AsMut<[T]> for [T; 22] [src]

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

impl<T> AsMut<[T]> for [T; 23] [src]

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

impl<T> AsMut<[T]> for [T; 24] [src]

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

impl<T> AsMut<[T]> for [T; 25] [src]

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

impl<T> AsMut<[T]> for [T; 26] [src]

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

impl<T> AsMut<[T]> for [T; 27] [src]

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

impl<T> AsMut<[T]> for [T; 28] [src]

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

impl<T> AsMut<[T]> for [T; 29] [src]

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

impl<T> AsMut<[T]> for [T; 30] [src]

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

impl<T> AsMut<[T]> for [T; 31] [src]

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

impl<T> AsMut<[T]> for [T; 32] [src]

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

impl<T> BorrowMut<[T]> for [T; 0]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 1]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 2]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 3]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 4]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 5]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 6]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 7]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 8]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 9]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 10]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 11]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 12]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 13]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 14]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 15]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 16]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 17]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 18]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 19]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 20]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 21]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 22]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 23]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 24]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 25]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 26]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 27]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 28]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 29]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 30]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 31]

1.4.0

[src]

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

impl<T> BorrowMut<[T]> for [T; 32]

1.4.0

[src]

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

impl<T> Debug for [T; 0] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 1] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 2] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 3] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 4] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 5] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 6] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 7] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 8] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 9] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 10] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 11] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 12] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 13] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 14] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 15] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 16] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 17] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 18] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 19] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 20] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 21] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 22] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 23] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 24] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 25] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 26] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 27] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 28] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 29] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 30] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 31] where
    T: Debug,  [src]

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

impl<T> Debug for [T; 32] where
    T: Debug,  [src]

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

impl<T> Ord for [T; 0] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 1] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 2] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 3] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 4] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 5] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 6] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 7] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 8] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 9] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 10] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 11] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 12] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 13] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 14] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 15] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 16] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 17] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 18] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 19] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 20] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 21] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 22] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 23] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 24] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 25] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 26] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 27] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 28] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 29] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 30] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 31] where
    T: Ord,  [src]

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

impl<T> Ord for [T; 32] where
    T: Ord,  [src]

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

impl<'a, 'b, A, B> PartialEq<[B; 0]> for [A; 0] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 0] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 0] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 0] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 1]> for [A; 1] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 1] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 1] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 1] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 2]> for [A; 2] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 2] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 2] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 2] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 3]> for [A; 3] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 3] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 3] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 3] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 4]> for [A; 4] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 4] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 4] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 4] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 5]> for [A; 5] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 5] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 5] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 5] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 6]> for [A; 6] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 6] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 6] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 6] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 7]> for [A; 7] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 7] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 7] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 7] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 8]> for [A; 8] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 8] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 8] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 8] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 9]> for [A; 9] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 9] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 9] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 9] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 10]> for [A; 10] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 10] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 10] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 10] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 11]> for [A; 11] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 11] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 11] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 11] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 12]> for [A; 12] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 12] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 12] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 12] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 13]> for [A; 13] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 13] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 13] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 13] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 14]> for [A; 14] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 14] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 14] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 14] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 15]> for [A; 15] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 15] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 15] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 15] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 16]> for [A; 16] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 16] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 16] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 16] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 17]> for [A; 17] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 17] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 17] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 17] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 18]> for [A; 18] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 18] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 18] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 18] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 19]> for [A; 19] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 19] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 19] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 19] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 20]> for [A; 20] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 20] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 20] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 20] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 21]> for [A; 21] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 21] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 21] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 21] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 22]> for [A; 22] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 22] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 22] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 22] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 23]> for [A; 23] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 23] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 23] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 23] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 24]> for [A; 24] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 24] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 24] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 24] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 25]> for [A; 25] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 25] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 25] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 25] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 26]> for [A; 26] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 26] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 26] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 26] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 27]> for [A; 27] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 27] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 27] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 27] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 28]> for [A; 28] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 28] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 28] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 28] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 29]> for [A; 29] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 29] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 29] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 29] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 30]> for [A; 30] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 30] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 30] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 30] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 31]> for [A; 31] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 31] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 31] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 31] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B; 32]> for [A; 32] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 32] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 32] where
    A: PartialEq<B>,  [src]

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 32] where
    A: PartialEq<B>,  [src]

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

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

impl<T> Clone for [T; 0] where
    T: Copy,  [src]

fn clone(&self) -> [T; 0]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 1] where
    T: Copy,  [src]

fn clone(&self) -> [T; 1]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 2] where
    T: Copy,  [src]

fn clone(&self) -> [T; 2]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 3] where
    T: Copy,  [src]

fn clone(&self) -> [T; 3]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 4] where
    T: Copy,  [src]

fn clone(&self) -> [T; 4]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 5] where
    T: Copy,  [src]

fn clone(&self) -> [T; 5]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 6] where
    T: Copy,  [src]

fn clone(&self) -> [T; 6]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 7] where
    T: Copy,  [src]

fn clone(&self) -> [T; 7]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 8] where
    T: Copy,  [src]

fn clone(&self) -> [T; 8]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 9] where
    T: Copy,  [src]

fn clone(&self) -> [T; 9]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 10] where
    T: Copy,  [src]

fn clone(&self) -> [T; 10]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 11] where
    T: Copy,  [src]

fn clone(&self) -> [T; 11]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 12] where
    T: Copy,  [src]

fn clone(&self) -> [T; 12]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 13] where
    T: Copy,  [src]

fn clone(&self) -> [T; 13]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 14] where
    T: Copy,  [src]

fn clone(&self) -> [T; 14]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 15] where
    T: Copy,  [src]

fn clone(&self) -> [T; 15]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 16] where
    T: Copy,  [src]

fn clone(&self) -> [T; 16]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 17] where
    T: Copy,  [src]

fn clone(&self) -> [T; 17]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 18] where
    T: Copy,  [src]

fn clone(&self) -> [T; 18]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 19] where
    T: Copy,  [src]

fn clone(&self) -> [T; 19]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 20] where
    T: Copy,  [src]

fn clone(&self) -> [T; 20]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 21] where
    T: Copy,  [src]

fn clone(&self) -> [T; 21]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 22] where
    T: Copy,  [src]

fn clone(&self) -> [T; 22]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 23] where
    T: Copy,  [src]

fn clone(&self) -> [T; 23]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 24] where
    T: Copy,  [src]

fn clone(&self) -> [T; 24]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 25] where
    T: Copy,  [src]

fn clone(&self) -> [T; 25]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 26] where
    T: Copy,  [src]

fn clone(&self) -> [T; 26]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 27] where
    T: Copy,  [src]

fn clone(&self) -> [T; 27]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 28] where
    T: Copy,  [src]

fn clone(&self) -> [T; 28]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 29] where
    T: Copy,  [src]

fn clone(&self) -> [T; 29]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 30] where
    T: Copy,  [src]

fn clone(&self) -> [T; 30]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 31] where
    T: Copy,  [src]

fn clone(&self) -> [T; 31]

fn clone_from(&mut self, source: &Self)

impl<T> Clone for [T; 32] where
    T: Copy,  [src]

fn clone(&self) -> [T; 32]

fn clone_from(&mut self, source: &Self)

impl<T> PartialOrd<[T; 0]> for [T; 0] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 1]> for [T; 1] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 2]> for [T; 2] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 3]> for [T; 3] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 4]> for [T; 4] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 5]> for [T; 5] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 6]> for [T; 6] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 7]> for [T; 7] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 8]> for [T; 8] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 9]> for [T; 9] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 10]> for [T; 10] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 11]> for [T; 11] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 12]> for [T; 12] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 13]> for [T; 13] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 14]> for [T; 14] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 15]> for [T; 15] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 16]> for [T; 16] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 17]> for [T; 17] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 18]> for [T; 18] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 19]> for [T; 19] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 20]> for [T; 20] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 21]> for [T; 21] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 22]> for [T; 22] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 23]> for [T; 23] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 24]> for [T; 24] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 25]> for [T; 25] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 26]> for [T; 26] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 27]> for [T; 27] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 28]> for [T; 28] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 29]> for [T; 29] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 30]> for [T; 30] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 31]> for [T; 31] where
    T: PartialOrd<T>,  [src]

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

impl<T> PartialOrd<[T; 32]> for [T; 32] where
    T: PartialOrd<T>,  [src]

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

impl<T> Hash for [T; 0] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 1] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 2] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 3] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 4] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 5] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 6] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 7] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 8] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 9] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 10] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 11] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 12] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 13] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 14] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 15] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 16] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 17] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 18] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 19] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 20] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 21] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 22] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 23] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 24] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 25] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 26] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 27] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 28] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 29] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 30] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 31] where
    T: Hash,  [src]

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

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

1.3.0

impl<T> Hash for [T; 32] where
    T: Hash,  [src]

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

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

1.3.0

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

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] [src]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

impl<T> AsRef<[T]> for [T; 0] [src]

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

impl<T> AsRef<[T]> for [T; 1] [src]

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

impl<T> AsRef<[T]> for [T; 2] [src]

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

impl<T> AsRef<[T]> for [T; 3] [src]

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

impl<T> AsRef<[T]> for [T; 4] [src]

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

impl<T> AsRef<[T]> for [T; 5] [src]

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

impl<T> AsRef<[T]> for [T; 6] [src]

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

impl<T> AsRef<[T]> for [T; 7] [src]

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

impl<T> AsRef<[T]> for [T; 8] [src]

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

impl<T> AsRef<[T]> for [T; 9] [src]

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

impl<T> AsRef<[T]> for [T; 10] [src]

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

impl<T> AsRef<[T]> for [T; 11] [src]

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

impl<T> AsRef<[T]> for [T; 12] [src]

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

impl<T> AsRef<[T]> for [T; 13] [src]

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

impl<T> AsRef<[T]> for [T; 14] [src]

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

impl<T> AsRef<[T]> for [T; 15] [src]

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

impl<T> AsRef<[T]> for [T; 16] [src]

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

impl<T> AsRef<[T]> for [T; 17] [src]

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

impl<T> AsRef<[T]> for [T; 18] [src]

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

impl<T> AsRef<[T]> for [T; 19] [src]

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

impl<T> AsRef<[T]> for [T; 20] [src]

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

impl<T> AsRef<[T]> for [T; 21] [src]

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

impl<T> AsRef<[T]> for [T; 22] [src]

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

impl<T> AsRef<[T]> for [T; 23] [src]

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

impl<T> AsRef<[T]> for [T; 24] [src]

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

impl<T> AsRef<[T]> for [T; 25] [src]

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

impl<T> AsRef<[T]> for [T; 26] [src]

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

impl<T> AsRef<[T]> for [T; 27] [src]

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

impl<T> AsRef<[T]> for [T; 28] [src]

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

impl<T> AsRef<[T]> for [T; 29] [src]

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

impl<T> AsRef<[T]> for [T; 30] [src]

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

impl<T> AsRef<[T]> for [T; 31] [src]

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

impl<T> AsRef<[T]> for [T; 32] [src]

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

impl<T> Borrow<[T]> for [T; 0]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 1]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 2]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 3]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 4]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 5]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 6]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 7]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 8]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 9]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 10]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 11]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 12]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 13]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 14]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 15]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 16]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 17]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 18]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 19]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 20]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 21]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 22]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 23]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 24]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 25]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 26]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 27]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 28]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 29]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 30]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 31]

1.4.0

[src]

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

impl<T> Borrow<[T]> for [T; 32]

1.4.0

[src]

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