Trait core::slice::SliceExtExperimental

pub trait SliceExt<T>: ?Sized {
    fn slice<'a>(&'a self, start: uint, end: uint) -> &'a [T];
    fn slice_from<'a>(&'a self, start: uint) -> &'a [T];
    fn slice_to<'a>(&'a self, end: uint) -> &'a [T];
    fn split_at<'a>(&'a self, mid: uint) -> (&'a [T], &'a [T]);
    fn iter<'a>(&'a self) -> Iter<'a, T>;
    fn split<'a, P>(&'a self, pred: P) -> Split<'a, T, P> where P: FnMut(&T) -> bool;
    fn splitn<'a, P>(&'a self, n: uint, pred: P) -> SplitN<'a, T, P> where P: FnMut(&T) -> bool;
    fn rsplitn<'a, P>(&'a self, n: uint, pred: P) -> RSplitN<'a, T, P> where P: FnMut(&T) -> bool;
    fn windows<'a>(&'a self, size: uint) -> Windows<'a, T>;
    fn chunks<'a>(&'a self, size: uint) -> Chunks<'a, T>;
    fn get<'a>(&'a self, index: uint) -> Option<&'a T>;
    fn first<'a>(&'a self) -> Option<&'a T>;
    fn tail<'a>(&'a self) -> &'a [T];
    fn init<'a>(&'a self) -> &'a [T];
    fn last<'a>(&'a self) -> Option<&'a T>;
    unsafe fn get_unchecked<'a>(&'a self, index: uint) -> &'a T;
    fn as_ptr(&self) -> *const T;
    fn binary_search_by<F>(&self, f: F) -> Result<uint, uint> where F: FnMut(&T) -> Ordering;
    fn len(&self) -> uint;
    fn get_mut<'a>(&'a mut self, index: uint) -> Option<&'a mut T>;
    fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T];
    fn slice_mut<'a>(&'a mut self, start: uint, end: uint) -> &'a mut [T];
    fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T];
    fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T];
    fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T>;
    fn first_mut<'a>(&'a mut self) -> Option<&'a mut T>;
    fn tail_mut<'a>(&'a mut self) -> &'a mut [T];
    fn init_mut<'a>(&'a mut self) -> &'a mut [T];
    fn last_mut<'a>(&'a mut self) -> Option<&'a mut T>;
    fn split_mut<'a, P>(&'a mut self, pred: P) -> SplitMut<'a, T, P> where P: FnMut(&T) -> bool;
    fn splitn_mut<P>(&mut self, n: uint, pred: P) -> SplitNMut<T, P> where P: FnMut(&T) -> bool;
    fn rsplitn_mut<P>(&mut self, n: uint, pred: P) -> RSplitNMut<T, P> where P: FnMut(&T) -> bool;
    fn chunks_mut<'a>(&'a mut self, chunk_size: uint) -> ChunksMut<'a, T>;
    fn swap(&mut self, a: uint, b: uint);
    fn split_at_mut<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]);
    fn reverse(&mut self);
    unsafe fn get_unchecked_mut<'a>(&'a mut self, index: uint) -> &'a mut T;
    fn as_mut_ptr(&mut self) -> *mut T;

    fn is_empty(&self) -> bool { ... }
}

Extension methods for slices.

Required Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn as_ptr(&self) -> *const T

fn binary_search_by<F>(&self, f: F) -> Result<uint, uint> where F: FnMut(&T) -> Ordering

fn len(&self) -> uint

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

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

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

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

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

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

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

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

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

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

fn split_mut<'a, P>(&'a mut self, pred: P) -> SplitMut<'a, T, P> where P: FnMut(&T) -> bool

fn splitn_mut<P>(&mut self, n: uint, pred: P) -> SplitNMut<T, P> where P: FnMut(&T) -> bool

fn rsplitn_mut<P>(&mut self, n: uint, pred: P) -> RSplitNMut<T, P> where P: FnMut(&T) -> bool

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

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

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

fn reverse(&mut self)

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

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

Provided Methods

fn is_empty(&self) -> bool

Implementors

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