core

Modules

anyatomicborrowcellcharclonecmpdefaultf32f64finallyfmthashi16i32i64i8intintrinsicsiterkindsmemnonzeronumopsoptionpanickingpreludeptrrawresultsimdslicestru16u32u64u8uint

Macros

assert!assert_eq!debug_assert!debug_assert_eq!panic!try!unreachable!write!writeln!

Primitive Type slice [-]  [+]

Slice management and manipulation

For more details std::slice.

Trait Implementations

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

fn repr(&self) -> T

impl MutableByteVector for [u8]

fn set_memory(&mut self, value: u8)

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>(&'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(&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> where F: FnMut(&T) -> Ordering

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>(&'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<'a, P>(&'a mut self, pred: P) -> SplitMut<'a, T, P> where P: FnMut(&T) -> bool

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

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

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, index: &uint) -> &T

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

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

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

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

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

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

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

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

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

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

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

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

impl<T: PartialEq> 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 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>(&'a self) -> &'a [T]

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

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

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

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

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

impl<T: Eq> Eq for [T]

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

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

impl<'a, T: PartialEq, V: AsSlice<T> + ?Sized> 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> 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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..0] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..1] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..2] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..3] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..4] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..5] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..6] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..7] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..8] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..9] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..10] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..11] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..12] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..13] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..14] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..15] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..16] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..17] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..18] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..19] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..20] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..21] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..22] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..23] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..24] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..25] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..26] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..27] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..28] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..29] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..30] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..31] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, A, B, Rhs> PartialEq<Rhs> for [A, ..32] where A: PartialEq<B>, Rhs: Deref<[B]>

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

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

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

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

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

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