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!(1i, 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!(1i, 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[int] = &mut [1i, 2, 3]; x[1] = 7; assert_eq!(x[0], 1); assert_eq!(x[1], 7); assert_eq!(x[2], 3); }

let x: &mut[int] = &mut [1i, 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):

#![feature(slicing_syntax)] fn main() { let numbers = [0i, 1i, 2i]; let last_numbers = numbers[1..3]; // last_numbers is now &[1i, 2i] }

#![feature(slicing_syntax)]
fn main() {
    let numbers = [0i, 1i, 2i];
    let last_numbers = numbers[1..3];
    // last_numbers is now &[1i, 2i]
}

Implementations of other traits

There are several implementations of common traits for slices. Some examples include:

• Clone
• Eq, Ord - for immutable slices whose element type are Eq or Ord.
• Hash - for slices whose element type is Hash

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 int, the element type of the iterator is &int.

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

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

• .iter_mut() returns an iterator that allows modifying each value.
• Further iterators exist that split, chunk or permute the slice.

Trait Implementations

impl AsciiExt<Vec<u8>> for [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

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

fn repr(&self) -> Slice<T>

impl<T> SliceExt<T> for [T]

fn slice(&self, start: uint, end: uint) -> &[T]

fn slice_from(&self, start: uint) -> &[T]

fn slice_to(&self, end: uint) -> &[T]

fn split_at(&self, mid: uint) -> (&[T], &[T])

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

fn split<P>(&'a self, pred: P) -> Split<'a, T, P>

fn splitn<P>(&'a self, n: uint, pred: P) -> SplitN<'a, T, P>

fn rsplitn<P>(&'a self, n: uint, pred: P) -> RSplitN<'a, T, P>

fn windows(&self, size: uint) -> Windows<T>

fn chunks(&self, size: uint) -> Chunks<T>

fn get(&self, index: uint) -> 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: uint) -> &T

fn as_ptr(&self) -> *const T

fn binary_search_by<F>(&self, f: F) -> Result<uint, uint>

fn len(&self) -> uint

fn get_mut(&mut self, index: uint) -> Option<&mut T>

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

fn slice_mut(&mut self, start: uint, end: uint) -> &mut [T]

fn slice_from_mut(&mut self, start: uint) -> &mut [T]

fn slice_to_mut(&mut self, end: uint) -> &mut [T]

fn split_at_mut(&mut self, mid: uint) -> (&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>

fn splitn_mut<P>(&'a mut self, n: uint, pred: P) -> SplitNMut<'a, T, P>

fn rsplitn_mut<P>(&'a mut self, n: uint, pred: P) -> RSplitNMut<'a, T, P>

fn chunks_mut(&mut self, chunk_size: uint) -> ChunksMut<T>

fn swap(&mut self, a: uint, b: uint)

fn reverse(&mut self)

unsafe fn get_unchecked_mut(&mut self, index: uint) -> &mut T

fn as_mut_ptr(&mut self) -> *mut T

fn is_empty(&self) -> bool

impl<T> Index<uint, T> for [T]

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

impl<T> IndexMut<uint, T> for [T]

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

impl<T> Slice<uint, [T]> for [T]

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

fn slice_from_or_fail(&'a self, start: &uint) -> &'a [T]

fn slice_to_or_fail(&'a self, end: &uint) -> &'a [T]

fn slice_or_fail(&'a self, start: &uint, end: &uint) -> &'a [T]

impl<T> SliceMut<uint, [T]> for [T]

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

fn slice_from_or_fail_mut(&'a mut self, start: &uint) -> &'a mut [T]

fn slice_to_or_fail_mut(&'a mut self, end: &uint) -> &'a mut [T]

fn slice_or_fail_mut(&'a mut self, start: &uint, end: &uint) -> &'a mut [T]

impl<T: PartialEq<T>> PartialEqSliceExt<T> for [T]

fn position_elem(&self, x: &T) -> Option<uint>

fn rposition_elem(&self, t: &T) -> Option<uint>

fn contains(&self, x: &T) -> bool

fn starts_with(&self, needle: &[T]) -> bool

fn ends_with(&self, needle: &[T]) -> bool

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

fn binary_search(&self, x: &T) -> Result<uint, uint>

fn next_permutation(&mut self) -> bool

fn prev_permutation(&mut self) -> bool

impl<T: Clone> CloneSliceExt<T> for [T]

fn clone_from_slice(&mut self, src: &[T]) -> uint

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 MutableByteVector for [u8]

fn set_memory(&mut self, value: u8)

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

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

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

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

impl<T: Eq> Eq for [T]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialEq<T>, V: AsSlice<T>> Equiv<V> for [T]

fn equiv(&self, other: &V) -> bool

impl<'a, T: PartialEq<T>, V: AsSlice<T>> Equiv<V> for &'a mut [T]

fn equiv(&self, other: &V) -> bool

impl<T: Ord> Ord for [T]

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

impl<T: PartialOrd<T>> PartialOrd<[T]> for [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<uint, int> for [uint]

fn as_unsigned(&self) -> &[uint]

fn as_signed(&self) -> &[int]

fn as_unsigned_mut(&mut self) -> &mut [uint]

fn as_signed_mut(&mut self) -> &mut [int]

impl IntSliceExt<uint, int> for [int]

fn as_unsigned(&self) -> &[uint]

fn as_signed(&self) -> &[int]

fn as_unsigned_mut(&mut self) -> &mut [uint]

fn as_signed_mut(&mut self) -> &mut [int]

impl<'a> CharEq for &'a [char]

fn matches(&mut self, c: char) -> bool

fn only_ascii(&self) -> bool

impl<S: Writer, T: Hash<S>> Hash<S> for [T]

fn hash(&self, state: &mut S)

impl<T: Show> Show for [T]

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

impl<T> Clone for [T, ..0]

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

fn clone_from(&mut self, &[T, ..0])

impl<T: Show> Show for [T, ..0]

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

impl<A, B> PartialEq<[B, ..0]> for [A, ..0]

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]

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

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

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

impl<T: Eq> Eq for [T, ..0]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..0]> for [T, ..0]

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> Ord for [T, ..0]

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

impl<T> Clone for [T, ..1]

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

fn clone_from(&mut self, &[T, ..1])

impl<T: Show> Show for [T, ..1]

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

impl<A, B> PartialEq<[B, ..1]> for [A, ..1]

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]

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

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

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

impl<T: Eq> Eq for [T, ..1]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..1]> for [T, ..1]

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> Ord for [T, ..1]

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

impl<T> Clone for [T, ..2]

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

fn clone_from(&mut self, &[T, ..2])

impl<T: Show> Show for [T, ..2]

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

impl<A, B> PartialEq<[B, ..2]> for [A, ..2]

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]

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

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

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

impl<T: Eq> Eq for [T, ..2]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..2]> for [T, ..2]

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> Ord for [T, ..2]

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

impl<T> Clone for [T, ..3]

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

fn clone_from(&mut self, &[T, ..3])

impl<T: Show> Show for [T, ..3]

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

impl<A, B> PartialEq<[B, ..3]> for [A, ..3]

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]

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

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

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

impl<T: Eq> Eq for [T, ..3]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..3]> for [T, ..3]

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> Ord for [T, ..3]

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

impl<T> Clone for [T, ..4]

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

fn clone_from(&mut self, &[T, ..4])

impl<T: Show> Show for [T, ..4]

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

impl<A, B> PartialEq<[B, ..4]> for [A, ..4]

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]

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

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

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

impl<T: Eq> Eq for [T, ..4]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..4]> for [T, ..4]

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> Ord for [T, ..4]

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

impl<T> Clone for [T, ..5]

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

fn clone_from(&mut self, &[T, ..5])

impl<T: Show> Show for [T, ..5]

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

impl<A, B> PartialEq<[B, ..5]> for [A, ..5]

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]

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

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

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

impl<T: Eq> Eq for [T, ..5]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..5]> for [T, ..5]

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> Ord for [T, ..5]

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

impl<T> Clone for [T, ..6]

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

fn clone_from(&mut self, &[T, ..6])

impl<T: Show> Show for [T, ..6]

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

impl<A, B> PartialEq<[B, ..6]> for [A, ..6]

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]

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

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

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

impl<T: Eq> Eq for [T, ..6]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..6]> for [T, ..6]

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> Ord for [T, ..6]

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

impl<T> Clone for [T, ..7]

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

fn clone_from(&mut self, &[T, ..7])

impl<T: Show> Show for [T, ..7]

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

impl<A, B> PartialEq<[B, ..7]> for [A, ..7]

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]

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

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

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

impl<T: Eq> Eq for [T, ..7]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..7]> for [T, ..7]

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> Ord for [T, ..7]

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

impl<T> Clone for [T, ..8]

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

fn clone_from(&mut self, &[T, ..8])

impl<T: Show> Show for [T, ..8]

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

impl<A, B> PartialEq<[B, ..8]> for [A, ..8]

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]

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

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

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

impl<T: Eq> Eq for [T, ..8]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..8]> for [T, ..8]

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> Ord for [T, ..8]

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

impl<T> Clone for [T, ..9]

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

fn clone_from(&mut self, &[T, ..9])

impl<T: Show> Show for [T, ..9]

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

impl<A, B> PartialEq<[B, ..9]> for [A, ..9]

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]

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

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

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

impl<T: Eq> Eq for [T, ..9]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..9]> for [T, ..9]

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> Ord for [T, ..9]

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

impl<T> Clone for [T, ..10]

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

fn clone_from(&mut self, &[T, ..10])

impl<T: Show> Show for [T, ..10]

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

impl<A, B> PartialEq<[B, ..10]> for [A, ..10]

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]

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

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

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

impl<T: Eq> Eq for [T, ..10]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..10]> for [T, ..10]

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> Ord for [T, ..10]

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

impl<T> Clone for [T, ..11]

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

fn clone_from(&mut self, &[T, ..11])

impl<T: Show> Show for [T, ..11]

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

impl<A, B> PartialEq<[B, ..11]> for [A, ..11]

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]

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

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

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

impl<T: Eq> Eq for [T, ..11]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..11]> for [T, ..11]

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> Ord for [T, ..11]

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

impl<T> Clone for [T, ..12]

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

fn clone_from(&mut self, &[T, ..12])

impl<T: Show> Show for [T, ..12]

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

impl<A, B> PartialEq<[B, ..12]> for [A, ..12]

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]

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

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

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

impl<T: Eq> Eq for [T, ..12]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..12]> for [T, ..12]

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> Ord for [T, ..12]

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

impl<T> Clone for [T, ..13]

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

fn clone_from(&mut self, &[T, ..13])

impl<T: Show> Show for [T, ..13]

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

impl<A, B> PartialEq<[B, ..13]> for [A, ..13]

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]

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

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

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

impl<T: Eq> Eq for [T, ..13]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..13]> for [T, ..13]

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> Ord for [T, ..13]

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

impl<T> Clone for [T, ..14]

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

fn clone_from(&mut self, &[T, ..14])

impl<T: Show> Show for [T, ..14]

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

impl<A, B> PartialEq<[B, ..14]> for [A, ..14]

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]

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

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

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

impl<T: Eq> Eq for [T, ..14]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..14]> for [T, ..14]

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> Ord for [T, ..14]

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

impl<T> Clone for [T, ..15]

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

fn clone_from(&mut self, &[T, ..15])

impl<T: Show> Show for [T, ..15]

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

impl<A, B> PartialEq<[B, ..15]> for [A, ..15]

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]

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

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

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

impl<T: Eq> Eq for [T, ..15]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..15]> for [T, ..15]

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> Ord for [T, ..15]

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

impl<T> Clone for [T, ..16]

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

fn clone_from(&mut self, &[T, ..16])

impl<T: Show> Show for [T, ..16]

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

impl<A, B> PartialEq<[B, ..16]> for [A, ..16]

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]

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

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

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

impl<T: Eq> Eq for [T, ..16]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..16]> for [T, ..16]

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> Ord for [T, ..16]

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

impl<T> Clone for [T, ..17]

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

fn clone_from(&mut self, &[T, ..17])

impl<T: Show> Show for [T, ..17]

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

impl<A, B> PartialEq<[B, ..17]> for [A, ..17]

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]

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

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

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

impl<T: Eq> Eq for [T, ..17]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..17]> for [T, ..17]

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> Ord for [T, ..17]

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

impl<T> Clone for [T, ..18]

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

fn clone_from(&mut self, &[T, ..18])

impl<T: Show> Show for [T, ..18]

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

impl<A, B> PartialEq<[B, ..18]> for [A, ..18]

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]

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

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

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

impl<T: Eq> Eq for [T, ..18]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..18]> for [T, ..18]

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> Ord for [T, ..18]

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

impl<T> Clone for [T, ..19]

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

fn clone_from(&mut self, &[T, ..19])

impl<T: Show> Show for [T, ..19]

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

impl<A, B> PartialEq<[B, ..19]> for [A, ..19]

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]

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

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

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

impl<T: Eq> Eq for [T, ..19]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..19]> for [T, ..19]

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> Ord for [T, ..19]

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

impl<T> Clone for [T, ..20]

fn clone(&self) -> [T, ..20]

fn clone_from(&mut self, &[T, ..20])

impl<T: Show> Show for [T, ..20]

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

impl<A, B> PartialEq<[B, ..20]> for [A, ..20]

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]

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

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

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

impl<T: Eq> Eq for [T, ..20]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..20]> for [T, ..20]

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> Ord for [T, ..20]

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

impl<T> Clone for [T, ..21]

fn clone(&self) -> [T, ..21]

fn clone_from(&mut self, &[T, ..21])

impl<T: Show> Show for [T, ..21]

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

impl<A, B> PartialEq<[B, ..21]> for [A, ..21]

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]

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

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

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

impl<T: Eq> Eq for [T, ..21]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..21]> for [T, ..21]

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> Ord for [T, ..21]

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

impl<T> Clone for [T, ..22]

fn clone(&self) -> [T, ..22]

fn clone_from(&mut self, &[T, ..22])

impl<T: Show> Show for [T, ..22]

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

impl<A, B> PartialEq<[B, ..22]> for [A, ..22]

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]

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

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

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

impl<T: Eq> Eq for [T, ..22]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..22]> for [T, ..22]

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> Ord for [T, ..22]

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

impl<T> Clone for [T, ..23]

fn clone(&self) -> [T, ..23]

fn clone_from(&mut self, &[T, ..23])

impl<T: Show> Show for [T, ..23]

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

impl<A, B> PartialEq<[B, ..23]> for [A, ..23]

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]

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

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

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

impl<T: Eq> Eq for [T, ..23]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..23]> for [T, ..23]

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> Ord for [T, ..23]

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

impl<T> Clone for [T, ..24]

fn clone(&self) -> [T, ..24]

fn clone_from(&mut self, &[T, ..24])

impl<T: Show> Show for [T, ..24]

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

impl<A, B> PartialEq<[B, ..24]> for [A, ..24]

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]

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

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

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

impl<T: Eq> Eq for [T, ..24]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..24]> for [T, ..24]

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> Ord for [T, ..24]

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

impl<T> Clone for [T, ..25]

fn clone(&self) -> [T, ..25]

fn clone_from(&mut self, &[T, ..25])

impl<T: Show> Show for [T, ..25]

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

impl<A, B> PartialEq<[B, ..25]> for [A, ..25]

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]

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

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

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

impl<T: Eq> Eq for [T, ..25]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..25]> for [T, ..25]

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> Ord for [T, ..25]

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

impl<T> Clone for [T, ..26]

fn clone(&self) -> [T, ..26]

fn clone_from(&mut self, &[T, ..26])

impl<T: Show> Show for [T, ..26]

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

impl<A, B> PartialEq<[B, ..26]> for [A, ..26]

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]

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

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

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

impl<T: Eq> Eq for [T, ..26]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..26]> for [T, ..26]

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> Ord for [T, ..26]

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

impl<T> Clone for [T, ..27]

fn clone(&self) -> [T, ..27]

fn clone_from(&mut self, &[T, ..27])

impl<T: Show> Show for [T, ..27]

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

impl<A, B> PartialEq<[B, ..27]> for [A, ..27]

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]

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

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

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

impl<T: Eq> Eq for [T, ..27]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..27]> for [T, ..27]

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> Ord for [T, ..27]

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

impl<T> Clone for [T, ..28]

fn clone(&self) -> [T, ..28]

fn clone_from(&mut self, &[T, ..28])

impl<T: Show> Show for [T, ..28]

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

impl<A, B> PartialEq<[B, ..28]> for [A, ..28]

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]

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

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

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

impl<T: Eq> Eq for [T, ..28]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..28]> for [T, ..28]

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> Ord for [T, ..28]

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

impl<T> Clone for [T, ..29]

fn clone(&self) -> [T, ..29]

fn clone_from(&mut self, &[T, ..29])

impl<T: Show> Show for [T, ..29]

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

impl<A, B> PartialEq<[B, ..29]> for [A, ..29]

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]

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

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

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

impl<T: Eq> Eq for [T, ..29]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..29]> for [T, ..29]

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> Ord for [T, ..29]

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

impl<T> Clone for [T, ..30]

fn clone(&self) -> [T, ..30]

fn clone_from(&mut self, &[T, ..30])

impl<T: Show> Show for [T, ..30]

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

impl<A, B> PartialEq<[B, ..30]> for [A, ..30]

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]

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

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

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

impl<T: Eq> Eq for [T, ..30]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..30]> for [T, ..30]

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> Ord for [T, ..30]

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

impl<T> Clone for [T, ..31]

fn clone(&self) -> [T, ..31]

fn clone_from(&mut self, &[T, ..31])

impl<T: Show> Show for [T, ..31]

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

impl<A, B> PartialEq<[B, ..31]> for [A, ..31]

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]

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

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

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

impl<T: Eq> Eq for [T, ..31]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..31]> for [T, ..31]

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> Ord for [T, ..31]

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

impl<T> Clone for [T, ..32]

fn clone(&self) -> [T, ..32]

fn clone_from(&mut self, &[T, ..32])

impl<T: Show> Show for [T, ..32]

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

impl<A, B> PartialEq<[B, ..32]> for [A, ..32]

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]

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

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

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

impl<T: Eq> Eq for [T, ..32]

fn assert_receiver_is_total_eq(&self)

impl<T: PartialOrd<T>> PartialOrd<[T, ..32]> for [T, ..32]

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> Ord for [T, ..32]

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

impl ToCStr for [u8]

fn to_c_str(&self) -> CString

unsafe fn to_c_str_unchecked(&self) -> CString

fn with_c_str<T, F>(&self, f: F) -> T where F: FnOnce(*const c_char) -> T

unsafe fn with_c_str_unchecked<T, F>(&self, f: F) -> T where F: FnOnce(*const c_char) -> T

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

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

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

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

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

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

fn read_exact(&mut self, len: uint) -> 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: uint) -> IoResult<u64>

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

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

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

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

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

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

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

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: uint)

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

impl<T> SliceExt<T> for [T]

fn sort_by<F>(&mut self, compare: F)

fn move_from(&mut self, src: Vec<T>, start: uint, end: uint) -> uint

fn slice(&'a self, start: uint, end: uint) -> &'a [T]

fn slice_from(&'a self, start: uint) -> &'a [T]

fn slice_to(&'a self, end: uint) -> &'a [T]

fn split_at(&'a self, mid: uint) -> (&'a [T], &'a [T])

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

fn split<F>(&self, pred: F) -> Split<T, F>

fn splitn<F>(&self, n: uint, pred: F) -> SplitN<T, F>

fn rsplitn<F>(&self, n: uint, pred: F) -> RSplitN<T, F>

fn windows(&'a self, size: uint) -> Windows<'a, T>

fn chunks(&'a self, size: uint) -> Chunks<'a, T>

fn get(&'a self, index: uint) -> Option<&'a T>

fn first(&'a self) -> Option<&'a T>

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

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

fn last(&'a self) -> Option<&'a T>

unsafe fn get_unchecked(&'a self, index: uint) -> &'a T

fn as_ptr(&self) -> *const T

fn binary_search_by<F>(&self, f: F) -> Result<uint, uint>

fn len(&self) -> uint

fn is_empty(&self) -> bool

fn get_mut(&'a mut self, index: uint) -> Option<&'a mut T>

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

fn slice_mut(&'a mut self, start: uint, end: uint) -> &'a mut [T]

fn slice_from_mut(&'a mut self, start: uint) -> &'a mut [T]

fn slice_to_mut(&'a mut self, end: uint) -> &'a mut [T]

fn iter_mut(&'a mut self) -> IterMut<'a, T>

fn first_mut(&'a mut self) -> Option<&'a mut T>

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

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

fn last_mut(&'a mut self) -> Option<&'a mut T>

fn split_mut<F>(&mut self, pred: F) -> SplitMut<T, F>

fn splitn_mut<F>(&mut self, n: uint, pred: F) -> SplitNMut<T, F>

fn rsplitn_mut<F>(&mut self, n: uint, pred: F) -> RSplitNMut<T, F>

fn chunks_mut(&'a mut self, chunk_size: uint) -> ChunksMut<'a, T>

fn swap(&mut self, a: uint, b: uint)

fn split_at_mut(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T])

fn reverse(&mut self)

unsafe fn get_unchecked_mut(&'a mut self, index: uint) -> &'a mut T

fn as_mut_ptr(&mut self) -> *mut T

fn head(&self) -> Option<&T>

unsafe fn unsafe_get(&self, uint) -> &T

fn is_empty(&self) -> bool

fn head_mut(&mut self) -> Option<&mut T>

unsafe fn unchecked_mut(&mut self, uint) -> &mut T

impl<T: Clone> CloneSliceExt<T> for [T]

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

Returns a copy of v.

fn partitioned<F>(&self, f: F) -> (Vec<T>, Vec<T>)

fn permutations(&self) -> Permutations<T>

Returns an iterator over all permutations of a vector.

fn clone_from_slice(&mut self, src: &[T]) -> uint

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

fn sort(&mut self)

fn binary_search(&self, x: &T) -> Result<uint, uint>

fn next_permutation(&mut self) -> bool

fn prev_permutation(&mut self) -> bool

fn binary_search_elem(&self, &T) -> Result<uint, uint>

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

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

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

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

fn connect_vec(&self, &T) -> Vec<T>

impl<T> BorrowFrom<Vec<T>> for [T]

fn borrow_from(owned: &Vec<T>) -> &[T]

impl<T> BorrowFromMut<Vec<T>> for [T]

fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T]

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

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

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

fn concat(&self) -> String

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

fn concat_vec(&self) -> String

fn connect_vec(&self, &str) -> String

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

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]

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, Vec<A>, [A]>> for &'b [B]

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

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

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

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

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

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

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

impl<'a, T> IntoCow<'a, Vec<T>, [T]> for &'a [T]

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