Primitive Type slice
[-]
[+]
Utilities for slice manipulation
The slice
module contains useful code to help work with slice values.
Slices are a view into a block of memory represented as a pointer and a length.
// slicing a Vec let vec = vec!(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:
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] }
Implementations of other traits
There are several implementations of common traits for slices. Some examples include:
Clone
Eq
,Ord
- for immutable slices whose element type areEq
orOrd
.Hash
- for slices whose element type isHash
Iteration
The method iter()
returns an iteration value for a slice. The iterator
yields references to the slice's elements, so if the element
type of the slice is int
, the element type of the iterator is &int
.
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]
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]
impl<T> IndexMut<uint, T> for [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]
impl<'a, T> Default for &'a [T]
impl MutableByteVector for [u8]
fn set_memory(&mut self, value: u8)
impl<A, B> PartialEq<[B]> for [A]
impl<T: Eq> Eq for [T]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialEq<T>, V: AsSlice<T>> Equiv<V> for [T]
impl<'a, T: PartialEq<T>, V: AsSlice<T>> Equiv<V> for &'a mut [T]
impl<T: Ord> Ord for [T]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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.