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 Items, 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 SlicePrelude. 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:
CloneEq,Ord- for immutable slices whose element type areEqorOrd.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<'a> AsciiCast<&'a [Ascii]> for &'a [u8]
unsafe fn to_ascii_nocheck(&self) -> &'a [Ascii]
fn is_ascii(&self) -> bool
fn to_ascii(&self) -> T
fn to_ascii_opt(&self) -> Option<T>
impl AsciiStr for [Ascii]
fn as_str_ascii<'a>(&'a self) -> &'a str
fn to_lower(&self) -> Vec<Ascii>
fn to_lowercase(&self) -> Vec<Ascii>
fn to_upper(&self) -> Vec<Ascii>
fn to_uppercase(&self) -> Vec<Ascii>
fn eq_ignore_case(&self, other: &[Ascii]) -> bool
impl AsciiExt<Vec<u8>> for [u8]
fn to_ascii_upper(&self) -> Vec<u8>
fn to_ascii_lower(&self) -> Vec<u8>
fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool
impl<T> Repr<Slice<T>> for [T]
impl<T> SlicePrelude<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) -> Items<'a, T>
fn split(&'a self, pred: |&T| -> bool) -> Splits<'a, T>
fn splitn(&'a self, n: uint, pred: |&T| -> bool) -> SplitsN<Splits<'a, T>>
fn rsplitn(&'a self, n: uint, pred: |&T| -> bool) -> SplitsN<Splits<'a, T>>
fn windows(&self, size: uint) -> Windows<T>
fn chunks(&self, size: uint) -> Chunks<T>
fn get(&self, index: uint) -> Option<&T>
fn head(&self) -> Option<&T>
fn tail(&self) -> &[T]
fn init(&self) -> &[T]
fn last(&self) -> Option<&T>
unsafe fn unsafe_get(&self, index: uint) -> &T
fn as_ptr(&self) -> *const T
fn binary_search(&self, f: |&T| -> Ordering) -> BinarySearchResult
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) -> MutItems<'a, T>
fn last_mut(&mut self) -> Option<&mut T>
fn head_mut(&mut self) -> Option<&mut T>
fn tail_mut(&mut self) -> &mut [T]
fn init_mut(&mut self) -> &mut [T]
fn split_mut(&'a mut self, pred: |&T| -> bool) -> MutSplits<'a, T>
fn splitn_mut(&'a mut self, n: uint, pred: |&T| -> bool) -> SplitsN<MutSplits<'a, T>>
fn rsplitn_mut(&'a mut self, n: uint, pred: |&T| -> bool) -> SplitsN<MutSplits<'a, T>>
fn chunks_mut(&mut self, chunk_size: uint) -> MutChunks<T>
fn swap(&mut self, a: uint, b: uint)
fn reverse(&mut self)
unsafe fn unsafe_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> PartialEqSlicePrelude<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> OrdSlicePrelude<T> for [T]
fn binary_search_elem(&self, x: &T) -> BinarySearchResult
fn next_permutation(&mut self) -> bool
fn prev_permutation(&mut self) -> bool
impl<T: Clone> CloneSlicePrelude<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<T: PartialEq> PartialEq for [T]
impl<T: Eq> Eq for [T]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialEq, V: AsSlice<T>> Equiv<V> for [T]
impl<'a, T: PartialEq, V: AsSlice<T>> Equiv<V> for &'a mut [T]
impl<T: Ord> Ord for [T]
impl<T: PartialOrd> PartialOrd 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 ImmutableIntSlice<u8, i8> for [u8]
impl ImmutableIntSlice<u8, i8> for [i8]
impl MutableIntSlice<u8, i8> for [u8]
fn as_unsigned_mut(&mut self) -> &mut [u8]
fn as_signed_mut(&mut self) -> &mut [i8]
impl MutableIntSlice<u8, i8> for [i8]
fn as_unsigned_mut(&mut self) -> &mut [u8]
fn as_signed_mut(&mut self) -> &mut [i8]
impl ImmutableIntSlice<u16, i16> for [u16]
impl ImmutableIntSlice<u16, i16> for [i16]
impl MutableIntSlice<u16, i16> for [u16]
fn as_unsigned_mut(&mut self) -> &mut [u16]
fn as_signed_mut(&mut self) -> &mut [i16]
impl MutableIntSlice<u16, i16> for [i16]
fn as_unsigned_mut(&mut self) -> &mut [u16]
fn as_signed_mut(&mut self) -> &mut [i16]
impl ImmutableIntSlice<u32, i32> for [u32]
impl ImmutableIntSlice<u32, i32> for [i32]
impl MutableIntSlice<u32, i32> for [u32]
fn as_unsigned_mut(&mut self) -> &mut [u32]
fn as_signed_mut(&mut self) -> &mut [i32]
impl MutableIntSlice<u32, i32> for [i32]
fn as_unsigned_mut(&mut self) -> &mut [u32]
fn as_signed_mut(&mut self) -> &mut [i32]
impl ImmutableIntSlice<u64, i64> for [u64]
impl ImmutableIntSlice<u64, i64> for [i64]
impl MutableIntSlice<u64, i64> for [u64]
fn as_unsigned_mut(&mut self) -> &mut [u64]
fn as_signed_mut(&mut self) -> &mut [i64]
impl MutableIntSlice<u64, i64> for [i64]
fn as_unsigned_mut(&mut self) -> &mut [u64]
fn as_signed_mut(&mut self) -> &mut [i64]
impl ImmutableIntSlice<uint, int> for [uint]
impl ImmutableIntSlice<uint, int> for [int]
impl MutableIntSlice<uint, int> for [uint]
fn as_unsigned_mut(&mut self) -> &mut [uint]
fn as_signed_mut(&mut self) -> &mut [int]
impl MutableIntSlice<uint, int> for [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<T: Show> Show for [T]
impl<T: Copy> Clone for [T, ..0]
fn clone(&self) -> [T, ..0]
fn clone_from(&mut self, &[T, ..0])
impl<T: Show> Show for [T, ..0]
impl<T: PartialEq> PartialEq for [T, ..0]
fn eq(&self, other: &[T, ..0]) -> bool
fn ne(&self, other: &[T, ..0]) -> bool
fn ne(&self, &[T, ..0]) -> bool
impl<T: Eq> Eq for [T, ..0]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..1]
fn clone(&self) -> [T, ..1]
fn clone_from(&mut self, &[T, ..1])
impl<T: Show> Show for [T, ..1]
impl<T: PartialEq> PartialEq for [T, ..1]
fn eq(&self, other: &[T, ..1]) -> bool
fn ne(&self, other: &[T, ..1]) -> bool
fn ne(&self, &[T, ..1]) -> bool
impl<T: Eq> Eq for [T, ..1]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..2]
fn clone(&self) -> [T, ..2]
fn clone_from(&mut self, &[T, ..2])
impl<T: Show> Show for [T, ..2]
impl<T: PartialEq> PartialEq for [T, ..2]
fn eq(&self, other: &[T, ..2]) -> bool
fn ne(&self, other: &[T, ..2]) -> bool
fn ne(&self, &[T, ..2]) -> bool
impl<T: Eq> Eq for [T, ..2]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..3]
fn clone(&self) -> [T, ..3]
fn clone_from(&mut self, &[T, ..3])
impl<T: Show> Show for [T, ..3]
impl<T: PartialEq> PartialEq for [T, ..3]
fn eq(&self, other: &[T, ..3]) -> bool
fn ne(&self, other: &[T, ..3]) -> bool
fn ne(&self, &[T, ..3]) -> bool
impl<T: Eq> Eq for [T, ..3]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..4]
fn clone(&self) -> [T, ..4]
fn clone_from(&mut self, &[T, ..4])
impl<T: Show> Show for [T, ..4]
impl<T: PartialEq> PartialEq for [T, ..4]
fn eq(&self, other: &[T, ..4]) -> bool
fn ne(&self, other: &[T, ..4]) -> bool
fn ne(&self, &[T, ..4]) -> bool
impl<T: Eq> Eq for [T, ..4]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..5]
fn clone(&self) -> [T, ..5]
fn clone_from(&mut self, &[T, ..5])
impl<T: Show> Show for [T, ..5]
impl<T: PartialEq> PartialEq for [T, ..5]
fn eq(&self, other: &[T, ..5]) -> bool
fn ne(&self, other: &[T, ..5]) -> bool
fn ne(&self, &[T, ..5]) -> bool
impl<T: Eq> Eq for [T, ..5]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..6]
fn clone(&self) -> [T, ..6]
fn clone_from(&mut self, &[T, ..6])
impl<T: Show> Show for [T, ..6]
impl<T: PartialEq> PartialEq for [T, ..6]
fn eq(&self, other: &[T, ..6]) -> bool
fn ne(&self, other: &[T, ..6]) -> bool
fn ne(&self, &[T, ..6]) -> bool
impl<T: Eq> Eq for [T, ..6]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..7]
fn clone(&self) -> [T, ..7]
fn clone_from(&mut self, &[T, ..7])
impl<T: Show> Show for [T, ..7]
impl<T: PartialEq> PartialEq for [T, ..7]
fn eq(&self, other: &[T, ..7]) -> bool
fn ne(&self, other: &[T, ..7]) -> bool
fn ne(&self, &[T, ..7]) -> bool
impl<T: Eq> Eq for [T, ..7]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..8]
fn clone(&self) -> [T, ..8]
fn clone_from(&mut self, &[T, ..8])
impl<T: Show> Show for [T, ..8]
impl<T: PartialEq> PartialEq for [T, ..8]
fn eq(&self, other: &[T, ..8]) -> bool
fn ne(&self, other: &[T, ..8]) -> bool
fn ne(&self, &[T, ..8]) -> bool
impl<T: Eq> Eq for [T, ..8]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..9]
fn clone(&self) -> [T, ..9]
fn clone_from(&mut self, &[T, ..9])
impl<T: Show> Show for [T, ..9]
impl<T: PartialEq> PartialEq for [T, ..9]
fn eq(&self, other: &[T, ..9]) -> bool
fn ne(&self, other: &[T, ..9]) -> bool
fn ne(&self, &[T, ..9]) -> bool
impl<T: Eq> Eq for [T, ..9]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..10]
fn clone(&self) -> [T, ..10]
fn clone_from(&mut self, &[T, ..10])
impl<T: Show> Show for [T, ..10]
impl<T: PartialEq> PartialEq for [T, ..10]
fn eq(&self, other: &[T, ..10]) -> bool
fn ne(&self, other: &[T, ..10]) -> bool
fn ne(&self, &[T, ..10]) -> bool
impl<T: Eq> Eq for [T, ..10]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..11]
fn clone(&self) -> [T, ..11]
fn clone_from(&mut self, &[T, ..11])
impl<T: Show> Show for [T, ..11]
impl<T: PartialEq> PartialEq for [T, ..11]
fn eq(&self, other: &[T, ..11]) -> bool
fn ne(&self, other: &[T, ..11]) -> bool
fn ne(&self, &[T, ..11]) -> bool
impl<T: Eq> Eq for [T, ..11]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..12]
fn clone(&self) -> [T, ..12]
fn clone_from(&mut self, &[T, ..12])
impl<T: Show> Show for [T, ..12]
impl<T: PartialEq> PartialEq for [T, ..12]
fn eq(&self, other: &[T, ..12]) -> bool
fn ne(&self, other: &[T, ..12]) -> bool
fn ne(&self, &[T, ..12]) -> bool
impl<T: Eq> Eq for [T, ..12]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..13]
fn clone(&self) -> [T, ..13]
fn clone_from(&mut self, &[T, ..13])
impl<T: Show> Show for [T, ..13]
impl<T: PartialEq> PartialEq for [T, ..13]
fn eq(&self, other: &[T, ..13]) -> bool
fn ne(&self, other: &[T, ..13]) -> bool
fn ne(&self, &[T, ..13]) -> bool
impl<T: Eq> Eq for [T, ..13]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..14]
fn clone(&self) -> [T, ..14]
fn clone_from(&mut self, &[T, ..14])
impl<T: Show> Show for [T, ..14]
impl<T: PartialEq> PartialEq for [T, ..14]
fn eq(&self, other: &[T, ..14]) -> bool
fn ne(&self, other: &[T, ..14]) -> bool
fn ne(&self, &[T, ..14]) -> bool
impl<T: Eq> Eq for [T, ..14]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..15]
fn clone(&self) -> [T, ..15]
fn clone_from(&mut self, &[T, ..15])
impl<T: Show> Show for [T, ..15]
impl<T: PartialEq> PartialEq for [T, ..15]
fn eq(&self, other: &[T, ..15]) -> bool
fn ne(&self, other: &[T, ..15]) -> bool
fn ne(&self, &[T, ..15]) -> bool
impl<T: Eq> Eq for [T, ..15]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..16]
fn clone(&self) -> [T, ..16]
fn clone_from(&mut self, &[T, ..16])
impl<T: Show> Show for [T, ..16]
impl<T: PartialEq> PartialEq for [T, ..16]
fn eq(&self, other: &[T, ..16]) -> bool
fn ne(&self, other: &[T, ..16]) -> bool
fn ne(&self, &[T, ..16]) -> bool
impl<T: Eq> Eq for [T, ..16]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..17]
fn clone(&self) -> [T, ..17]
fn clone_from(&mut self, &[T, ..17])
impl<T: Show> Show for [T, ..17]
impl<T: PartialEq> PartialEq for [T, ..17]
fn eq(&self, other: &[T, ..17]) -> bool
fn ne(&self, other: &[T, ..17]) -> bool
fn ne(&self, &[T, ..17]) -> bool
impl<T: Eq> Eq for [T, ..17]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..18]
fn clone(&self) -> [T, ..18]
fn clone_from(&mut self, &[T, ..18])
impl<T: Show> Show for [T, ..18]
impl<T: PartialEq> PartialEq for [T, ..18]
fn eq(&self, other: &[T, ..18]) -> bool
fn ne(&self, other: &[T, ..18]) -> bool
fn ne(&self, &[T, ..18]) -> bool
impl<T: Eq> Eq for [T, ..18]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..19]
fn clone(&self) -> [T, ..19]
fn clone_from(&mut self, &[T, ..19])
impl<T: Show> Show for [T, ..19]
impl<T: PartialEq> PartialEq for [T, ..19]
fn eq(&self, other: &[T, ..19]) -> bool
fn ne(&self, other: &[T, ..19]) -> bool
fn ne(&self, &[T, ..19]) -> bool
impl<T: Eq> Eq for [T, ..19]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..20]
fn clone(&self) -> [T, ..20]
fn clone_from(&mut self, &[T, ..20])
impl<T: Show> Show for [T, ..20]
impl<T: PartialEq> PartialEq for [T, ..20]
fn eq(&self, other: &[T, ..20]) -> bool
fn ne(&self, other: &[T, ..20]) -> bool
fn ne(&self, &[T, ..20]) -> bool
impl<T: Eq> Eq for [T, ..20]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..21]
fn clone(&self) -> [T, ..21]
fn clone_from(&mut self, &[T, ..21])
impl<T: Show> Show for [T, ..21]
impl<T: PartialEq> PartialEq for [T, ..21]
fn eq(&self, other: &[T, ..21]) -> bool
fn ne(&self, other: &[T, ..21]) -> bool
fn ne(&self, &[T, ..21]) -> bool
impl<T: Eq> Eq for [T, ..21]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..22]
fn clone(&self) -> [T, ..22]
fn clone_from(&mut self, &[T, ..22])
impl<T: Show> Show for [T, ..22]
impl<T: PartialEq> PartialEq for [T, ..22]
fn eq(&self, other: &[T, ..22]) -> bool
fn ne(&self, other: &[T, ..22]) -> bool
fn ne(&self, &[T, ..22]) -> bool
impl<T: Eq> Eq for [T, ..22]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..23]
fn clone(&self) -> [T, ..23]
fn clone_from(&mut self, &[T, ..23])
impl<T: Show> Show for [T, ..23]
impl<T: PartialEq> PartialEq for [T, ..23]
fn eq(&self, other: &[T, ..23]) -> bool
fn ne(&self, other: &[T, ..23]) -> bool
fn ne(&self, &[T, ..23]) -> bool
impl<T: Eq> Eq for [T, ..23]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..24]
fn clone(&self) -> [T, ..24]
fn clone_from(&mut self, &[T, ..24])
impl<T: Show> Show for [T, ..24]
impl<T: PartialEq> PartialEq for [T, ..24]
fn eq(&self, other: &[T, ..24]) -> bool
fn ne(&self, other: &[T, ..24]) -> bool
fn ne(&self, &[T, ..24]) -> bool
impl<T: Eq> Eq for [T, ..24]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..25]
fn clone(&self) -> [T, ..25]
fn clone_from(&mut self, &[T, ..25])
impl<T: Show> Show for [T, ..25]
impl<T: PartialEq> PartialEq for [T, ..25]
fn eq(&self, other: &[T, ..25]) -> bool
fn ne(&self, other: &[T, ..25]) -> bool
fn ne(&self, &[T, ..25]) -> bool
impl<T: Eq> Eq for [T, ..25]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..26]
fn clone(&self) -> [T, ..26]
fn clone_from(&mut self, &[T, ..26])
impl<T: Show> Show for [T, ..26]
impl<T: PartialEq> PartialEq for [T, ..26]
fn eq(&self, other: &[T, ..26]) -> bool
fn ne(&self, other: &[T, ..26]) -> bool
fn ne(&self, &[T, ..26]) -> bool
impl<T: Eq> Eq for [T, ..26]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..27]
fn clone(&self) -> [T, ..27]
fn clone_from(&mut self, &[T, ..27])
impl<T: Show> Show for [T, ..27]
impl<T: PartialEq> PartialEq for [T, ..27]
fn eq(&self, other: &[T, ..27]) -> bool
fn ne(&self, other: &[T, ..27]) -> bool
fn ne(&self, &[T, ..27]) -> bool
impl<T: Eq> Eq for [T, ..27]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..28]
fn clone(&self) -> [T, ..28]
fn clone_from(&mut self, &[T, ..28])
impl<T: Show> Show for [T, ..28]
impl<T: PartialEq> PartialEq for [T, ..28]
fn eq(&self, other: &[T, ..28]) -> bool
fn ne(&self, other: &[T, ..28]) -> bool
fn ne(&self, &[T, ..28]) -> bool
impl<T: Eq> Eq for [T, ..28]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..29]
fn clone(&self) -> [T, ..29]
fn clone_from(&mut self, &[T, ..29])
impl<T: Show> Show for [T, ..29]
impl<T: PartialEq> PartialEq for [T, ..29]
fn eq(&self, other: &[T, ..29]) -> bool
fn ne(&self, other: &[T, ..29]) -> bool
fn ne(&self, &[T, ..29]) -> bool
impl<T: Eq> Eq for [T, ..29]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..30]
fn clone(&self) -> [T, ..30]
fn clone_from(&mut self, &[T, ..30])
impl<T: Show> Show for [T, ..30]
impl<T: PartialEq> PartialEq for [T, ..30]
fn eq(&self, other: &[T, ..30]) -> bool
fn ne(&self, other: &[T, ..30]) -> bool
fn ne(&self, &[T, ..30]) -> bool
impl<T: Eq> Eq for [T, ..30]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..31]
fn clone(&self) -> [T, ..31]
fn clone_from(&mut self, &[T, ..31])
impl<T: Show> Show for [T, ..31]
impl<T: PartialEq> PartialEq for [T, ..31]
fn eq(&self, other: &[T, ..31]) -> bool
fn ne(&self, other: &[T, ..31]) -> bool
fn ne(&self, &[T, ..31]) -> bool
impl<T: Eq> Eq for [T, ..31]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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: Copy> Clone for [T, ..32]
fn clone(&self) -> [T, ..32]
fn clone_from(&mut self, &[T, ..32])
impl<T: Show> Show for [T, ..32]
impl<T: PartialEq> PartialEq for [T, ..32]
fn eq(&self, other: &[T, ..32]) -> bool
fn ne(&self, other: &[T, ..32]) -> bool
fn ne(&self, &[T, ..32]) -> bool
impl<T: Eq> Eq for [T, ..32]
fn assert_receiver_is_total_eq(&self)
impl<T: PartialOrd> PartialOrd 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<'a, T: Clone, V: AsSlice<T>> VectorVector<T> for [V]
fn concat_vec(&self) -> Vec<T>
fn connect_vec(&self, sep: &T) -> Vec<T>
impl<T: Clone> CloneSliceAllocPrelude<T> for [T]
fn to_vec(&self) -> Vec<T>
Returns a copy of v.
fn partitioned(&self, f: |&T| -> bool) -> (Vec<T>, Vec<T>)
fn permutations(&self) -> Permutations<T>
Returns an iterator over all permutations of a vector.