Primitive Type slice

Slice management and manipulation

For more details std::slice.

Trait Implementations

`impl<'a, T> Clone for &'a [T]`

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

Return a shallow copy of the slice.

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

`impl<'a, T> Repr<Slice<T>> for &'a [T]`

`fn repr(&self) -> T`

`impl<'a, T: PartialEq> PartialEq for &'a [T]`

`fn eq(&self, other: &&'a [T]) -> bool`

`fn ne(&self, other: &&'a [T]) -> bool`

`impl<'a, T: Eq> Eq for &'a [T]`

`impl<'a, T: PartialEq, V: Vector<T>> Equiv<V> for &'a [T]`

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

`impl<'a, T: Ord> Ord for &'a [T]`

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

`impl<'a, T: PartialOrd> PartialOrd for &'a [T]`

`fn lt(&self, other: &&'a [T]) -> bool`

`fn le(&self, other: &&'a [T]) -> bool`

`fn ge(&self, other: &&'a [T]) -> bool`

`fn gt(&self, other: &&'a [T]) -> bool`

`impl<'a> MutableByteVector for &'a mut [u8]`

`fn set_memory(self, value: u8)`

`impl<'a, T> Vector<T> for &'a [T]`

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

`impl<'a, T> Collection for &'a [T]`

`fn len(&self) -> uint`

Returns the length of a vector

`fn is_empty(&self) -> bool`

`impl<'a, T> ImmutableVector<'a, T> for &'a [T]`

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

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

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

`fn iter(self) -> Items<'a, T>`

`fn split(self, pred: |&T|: 'a -> bool) -> Splits<'a, T>`

`fn splitn(self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<'a, T>`

`fn rsplitn(self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<'a, T>`

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

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

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

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

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

`fn tailn(&self, n: uint) -> &'a [T]`

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

`fn initn(&self, n: uint) -> &'a [T]`

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

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

`fn as_ptr(&self) -> *T`

`fn bsearch(&self, f: |&T| -> Ordering) -> Option<uint>`

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

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

`impl<'a, T: PartialEq> ImmutableEqVector<T> for &'a [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<'a, T: Ord> ImmutableOrdVector<T> for &'a [T]`

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

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

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

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

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

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

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

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

`fn mut_iter(self) -> MutItems<'a, T>`

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

`fn mut_split(self, pred: |&T|: 'a -> bool) -> MutSplits<'a, T>`

`fn mut_chunks(self, chunk_size: uint) -> MutChunks<'a, T>`

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

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

`fn swap(self, a: uint, b: uint)`

`fn reverse(self)`

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

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

`unsafe fn unsafe_set(self, index: uint, val: T)`

`unsafe fn init_elem(self, i: uint, val: T)`

`unsafe fn copy_memory(self, src: &[T])`

`impl<'a, T: Clone> MutableCloneableVector<T> for &'a mut [T]`

`fn copy_from(self, src: &[T]) -> uint`

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

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

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

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

`fn only_ascii(&self) -> bool`

`impl<'a, T: Show> Show for &'a [T]`

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

`impl<'a, T: Show> Show for &'a mut [T]`

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