Primitive Type slice

Slice management and manipulation

For more details std::slice.

Trait Implementations

impl<T> AsRef<[T]> for [T]

fn as_ref(&self) -> &[T]

impl<T> AsMut<[T]> for [T]

fn as_mut(&mut self) -> &mut [T]

impl<'a, 'b, A: Sized, B> PartialEq<[A; 0]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 0]) -> bool

fn ne(&self, other: &[A; 0]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 0]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 0]) -> bool

fn ne(&self, other: &[A; 0]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 0]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 0]) -> bool

fn ne(&self, other: &[A; 0]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 1]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 1]) -> bool

fn ne(&self, other: &[A; 1]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 1]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 1]) -> bool

fn ne(&self, other: &[A; 1]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 1]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 1]) -> bool

fn ne(&self, other: &[A; 1]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 2]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 2]) -> bool

fn ne(&self, other: &[A; 2]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 2]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 2]) -> bool

fn ne(&self, other: &[A; 2]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 2]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 2]) -> bool

fn ne(&self, other: &[A; 2]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 3]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 3]) -> bool

fn ne(&self, other: &[A; 3]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 3]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 3]) -> bool

fn ne(&self, other: &[A; 3]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 3]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 3]) -> bool

fn ne(&self, other: &[A; 3]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 4]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 4]) -> bool

fn ne(&self, other: &[A; 4]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 4]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 4]) -> bool

fn ne(&self, other: &[A; 4]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 4]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 4]) -> bool

fn ne(&self, other: &[A; 4]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 5]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 5]) -> bool

fn ne(&self, other: &[A; 5]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 5]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 5]) -> bool

fn ne(&self, other: &[A; 5]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 5]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 5]) -> bool

fn ne(&self, other: &[A; 5]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 6]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 6]) -> bool

fn ne(&self, other: &[A; 6]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 6]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 6]) -> bool

fn ne(&self, other: &[A; 6]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 6]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 6]) -> bool

fn ne(&self, other: &[A; 6]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 7]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 7]) -> bool

fn ne(&self, other: &[A; 7]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 7]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 7]) -> bool

fn ne(&self, other: &[A; 7]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 7]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 7]) -> bool

fn ne(&self, other: &[A; 7]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 8]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 8]) -> bool

fn ne(&self, other: &[A; 8]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 8]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 8]) -> bool

fn ne(&self, other: &[A; 8]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 8]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 8]) -> bool

fn ne(&self, other: &[A; 8]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 9]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 9]) -> bool

fn ne(&self, other: &[A; 9]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 9]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 9]) -> bool

fn ne(&self, other: &[A; 9]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 9]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 9]) -> bool

fn ne(&self, other: &[A; 9]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 10]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 10]) -> bool

fn ne(&self, other: &[A; 10]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 10]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 10]) -> bool

fn ne(&self, other: &[A; 10]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 10]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 10]) -> bool

fn ne(&self, other: &[A; 10]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 11]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 11]) -> bool

fn ne(&self, other: &[A; 11]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 11]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 11]) -> bool

fn ne(&self, other: &[A; 11]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 11]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 11]) -> bool

fn ne(&self, other: &[A; 11]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 12]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 12]) -> bool

fn ne(&self, other: &[A; 12]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 12]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 12]) -> bool

fn ne(&self, other: &[A; 12]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 12]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 12]) -> bool

fn ne(&self, other: &[A; 12]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 13]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 13]) -> bool

fn ne(&self, other: &[A; 13]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 13]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 13]) -> bool

fn ne(&self, other: &[A; 13]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 13]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 13]) -> bool

fn ne(&self, other: &[A; 13]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 14]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 14]) -> bool

fn ne(&self, other: &[A; 14]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 14]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 14]) -> bool

fn ne(&self, other: &[A; 14]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 14]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 14]) -> bool

fn ne(&self, other: &[A; 14]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 15]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 15]) -> bool

fn ne(&self, other: &[A; 15]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 15]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 15]) -> bool

fn ne(&self, other: &[A; 15]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 15]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 15]) -> bool

fn ne(&self, other: &[A; 15]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 16]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 16]) -> bool

fn ne(&self, other: &[A; 16]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 16]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 16]) -> bool

fn ne(&self, other: &[A; 16]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 16]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 16]) -> bool

fn ne(&self, other: &[A; 16]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 17]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 17]) -> bool

fn ne(&self, other: &[A; 17]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 17]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 17]) -> bool

fn ne(&self, other: &[A; 17]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 17]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 17]) -> bool

fn ne(&self, other: &[A; 17]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 18]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 18]) -> bool

fn ne(&self, other: &[A; 18]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 18]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 18]) -> bool

fn ne(&self, other: &[A; 18]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 18]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 18]) -> bool

fn ne(&self, other: &[A; 18]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 19]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 19]) -> bool

fn ne(&self, other: &[A; 19]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 19]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 19]) -> bool

fn ne(&self, other: &[A; 19]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 19]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 19]) -> bool

fn ne(&self, other: &[A; 19]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 20]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 20]) -> bool

fn ne(&self, other: &[A; 20]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 20]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 20]) -> bool

fn ne(&self, other: &[A; 20]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 20]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 20]) -> bool

fn ne(&self, other: &[A; 20]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 21]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 21]) -> bool

fn ne(&self, other: &[A; 21]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 21]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 21]) -> bool

fn ne(&self, other: &[A; 21]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 21]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 21]) -> bool

fn ne(&self, other: &[A; 21]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 22]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 22]) -> bool

fn ne(&self, other: &[A; 22]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 22]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 22]) -> bool

fn ne(&self, other: &[A; 22]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 22]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 22]) -> bool

fn ne(&self, other: &[A; 22]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 23]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 23]) -> bool

fn ne(&self, other: &[A; 23]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 23]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 23]) -> bool

fn ne(&self, other: &[A; 23]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 23]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 23]) -> bool

fn ne(&self, other: &[A; 23]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 24]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 24]) -> bool

fn ne(&self, other: &[A; 24]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 24]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 24]) -> bool

fn ne(&self, other: &[A; 24]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 24]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 24]) -> bool

fn ne(&self, other: &[A; 24]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 25]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 25]) -> bool

fn ne(&self, other: &[A; 25]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 25]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 25]) -> bool

fn ne(&self, other: &[A; 25]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 25]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 25]) -> bool

fn ne(&self, other: &[A; 25]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 26]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 26]) -> bool

fn ne(&self, other: &[A; 26]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 26]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 26]) -> bool

fn ne(&self, other: &[A; 26]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 26]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 26]) -> bool

fn ne(&self, other: &[A; 26]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 27]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 27]) -> bool

fn ne(&self, other: &[A; 27]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 27]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 27]) -> bool

fn ne(&self, other: &[A; 27]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 27]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 27]) -> bool

fn ne(&self, other: &[A; 27]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 28]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 28]) -> bool

fn ne(&self, other: &[A; 28]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 28]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 28]) -> bool

fn ne(&self, other: &[A; 28]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 28]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 28]) -> bool

fn ne(&self, other: &[A; 28]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 29]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 29]) -> bool

fn ne(&self, other: &[A; 29]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 29]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 29]) -> bool

fn ne(&self, other: &[A; 29]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 29]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 29]) -> bool

fn ne(&self, other: &[A; 29]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 30]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 30]) -> bool

fn ne(&self, other: &[A; 30]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 30]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 30]) -> bool

fn ne(&self, other: &[A; 30]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 30]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 30]) -> bool

fn ne(&self, other: &[A; 30]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 31]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 31]) -> bool

fn ne(&self, other: &[A; 31]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 31]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 31]) -> bool

fn ne(&self, other: &[A; 31]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 31]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 31]) -> bool

fn ne(&self, other: &[A; 31]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 32]> for [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 32]) -> bool

fn ne(&self, other: &[A; 32]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 32]> for &'b [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 32]) -> bool

fn ne(&self, other: &[A; 32]) -> bool

impl<'a, 'b, A: Sized, B> PartialEq<[A; 32]> for &'b mut [B] where B: PartialEq<A>

fn eq(&self, other: &[A; 32]) -> bool

fn ne(&self, other: &[A; 32]) -> bool

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

fn repr(&self) -> T

impl MutableByteVector for [u8]

fn set_memory(&mut self, value: u8)

impl<T> Index<usize> for [T]

type Output = T

fn index(&self, index: usize) -> &T

impl<T> IndexMut<usize> for [T]

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

impl<T> Index<Range<usize>> for [T]

type Output = [T]

fn index(&self, index: Range<usize>) -> &[T]

impl<T> Index<RangeTo<usize>> for [T]

type Output = [T]

fn index(&self, index: RangeTo<usize>) -> &[T]

impl<T> Index<RangeFrom<usize>> for [T]

type Output = [T]

fn index(&self, index: RangeFrom<usize>) -> &[T]

impl<T> Index<RangeFull> for [T]

type Output = [T]

fn index(&self, _index: RangeFull) -> &[T]

impl<T> IndexMut<Range<usize>> for [T]

fn index_mut(&mut self, index: Range<usize>) -> &mut [T]

impl<T> IndexMut<RangeTo<usize>> for [T]

fn index_mut(&mut self, index: RangeTo<usize>) -> &mut [T]

impl<T> IndexMut<RangeFrom<usize>> for [T]

fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut [T]

impl<T> IndexMut<RangeFull> for [T]

fn index_mut(&mut self, _index: RangeFull) -> &mut [T]

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

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

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

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

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

fn into_iter(self) -> IterMut<'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: 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<usize, isize> for [usize]

fn as_unsigned(&self) -> &[usize]

fn as_signed(&self) -> &[isize]

fn as_unsigned_mut(&mut self) -> &mut [usize]

fn as_signed_mut(&mut self) -> &mut [isize]

impl IntSliceExt<usize, isize> for [isize]

fn as_unsigned(&self) -> &[usize]

fn as_signed(&self) -> &[isize]

fn as_unsigned_mut(&mut self) -> &mut [usize]

fn as_signed_mut(&mut self) -> &mut [isize]

impl<'a, 'b> Pattern<'a> for &'b [char]

Searches for chars that are equal to any of the chars in the array

type Searcher = CharSliceSearcher<'a, 'b>

fn into_searcher(self, haystack: &'a str) -> CharSliceSearcher<'a, 'b>

fn is_contained_in(self, haystack: &'a str) -> bool

fn is_prefix_of(self, haystack: &'a str) -> bool

fn is_suffix_of(self, haystack: &'a str) -> bool where CharSliceSearcher<'a, 'b>: ReverseSearcher<'a>

impl<T: Hash> Hash for [T]

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H: Hasher>(data: &[Self], state: &mut H) where Self: Sized

impl<T: Debug> Debug for [T]

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