Trait IdxSliceIndex 

pub trait IdxSliceIndex<I, T>: Sealed
where
    I: Idx,
{
    type Output: ?Sized;

    // Required methods
    fn get(self, slice: &IndexSlice<I, [T]>) -> Option<&Self::Output>;
    fn get_mut(
        self,
        slice: &mut IndexSlice<I, [T]>,
    ) -> Option<&mut Self::Output>;
    fn index(self, slice: &IndexSlice<I, [T]>) -> &Self::Output;
    fn index_mut(self, slice: &mut IndexSlice<I, [T]>) -> &mut Self::Output;
}

This is the equivalent of the sealed core::slice::SliceIndex trait. It cannot be overridden from user, code nor should it normally need use directly (Outside of trait bounds, I guess).

Required Associated Types

type Output: ?Sized

Required Methods

fn get(self, slice: &IndexSlice<I, [T]>) -> Option<&Self::Output>

fn get_mut(self, slice: &mut IndexSlice<I, [T]>) -> Option<&mut Self::Output>

fn index(self, slice: &IndexSlice<I, [T]>) -> &Self::Output

fn index_mut(self, slice: &mut IndexSlice<I, [T]>) -> &mut Self::Output

Implementations on Foreign Types

impl<I, T> IdxSliceIndex<I, T> for usize

where I: Idx,

type Output = T

fn get( self, slice: &IndexSlice<I, [T]>, ) -> Option<&<usize as IdxSliceIndex<I, T>>::Output>

fn get_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> Option<&mut <usize as IdxSliceIndex<I, T>>::Output>

fn index( self, slice: &IndexSlice<I, [T]>, ) -> &<usize as IdxSliceIndex<I, T>>::Output

fn index_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> &mut <usize as IdxSliceIndex<I, T>>::Output

impl<I, T> IdxSliceIndex<I, T> for Range<I>

where I: Idx,

type Output = IndexSlice<I, [T]>

fn get( self, slice: &IndexSlice<I, [T]>, ) -> Option<&<Range<I> as IdxSliceIndex<I, T>>::Output>

fn get_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> Option<&mut <Range<I> as IdxSliceIndex<I, T>>::Output>

fn index( self, slice: &IndexSlice<I, [T]>, ) -> &<Range<I> as IdxSliceIndex<I, T>>::Output

fn index_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> &mut <Range<I> as IdxSliceIndex<I, T>>::Output

impl<I, T> IdxSliceIndex<I, T> for RangeFrom<I>

where I: Idx,

type Output = IndexSlice<I, [T]>

fn get( self, slice: &IndexSlice<I, [T]>, ) -> Option<&<RangeFrom<I> as IdxSliceIndex<I, T>>::Output>

fn get_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> Option<&mut <RangeFrom<I> as IdxSliceIndex<I, T>>::Output>

fn index( self, slice: &IndexSlice<I, [T]>, ) -> &<RangeFrom<I> as IdxSliceIndex<I, T>>::Output

fn index_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> &mut <RangeFrom<I> as IdxSliceIndex<I, T>>::Output

impl<I, T> IdxSliceIndex<I, T> for RangeFull

where I: Idx,

type Output = IndexSlice<I, [T]>

fn get( self, slice: &IndexSlice<I, [T]>, ) -> Option<&<RangeFull as IdxSliceIndex<I, T>>::Output>

fn get_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> Option<&mut <RangeFull as IdxSliceIndex<I, T>>::Output>

fn index( self, slice: &IndexSlice<I, [T]>, ) -> &<RangeFull as IdxSliceIndex<I, T>>::Output

fn index_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> &mut <RangeFull as IdxSliceIndex<I, T>>::Output

impl<I, T> IdxSliceIndex<I, T> for RangeInclusive<I>

where I: Idx,

type Output = IndexSlice<I, [T]>

fn get( self, slice: &IndexSlice<I, [T]>, ) -> Option<&<RangeInclusive<I> as IdxSliceIndex<I, T>>::Output>

fn get_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> Option<&mut <RangeInclusive<I> as IdxSliceIndex<I, T>>::Output>

fn index( self, slice: &IndexSlice<I, [T]>, ) -> &<RangeInclusive<I> as IdxSliceIndex<I, T>>::Output

fn index_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> &mut <RangeInclusive<I> as IdxSliceIndex<I, T>>::Output

impl<I, T> IdxSliceIndex<I, T> for RangeTo<I>

where I: Idx,

type Output = IndexSlice<I, [T]>

fn get( self, slice: &IndexSlice<I, [T]>, ) -> Option<&<RangeTo<I> as IdxSliceIndex<I, T>>::Output>

fn get_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> Option<&mut <RangeTo<I> as IdxSliceIndex<I, T>>::Output>

fn index( self, slice: &IndexSlice<I, [T]>, ) -> &<RangeTo<I> as IdxSliceIndex<I, T>>::Output

fn index_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> &mut <RangeTo<I> as IdxSliceIndex<I, T>>::Output

impl<I, T> IdxSliceIndex<I, T> for RangeToInclusive<I>

where I: Idx,

type Output = IndexSlice<I, [T]>

fn get( self, slice: &IndexSlice<I, [T]>, ) -> Option<&<RangeToInclusive<I> as IdxSliceIndex<I, T>>::Output>

fn get_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> Option<&mut <RangeToInclusive<I> as IdxSliceIndex<I, T>>::Output>

fn index( self, slice: &IndexSlice<I, [T]>, ) -> &<RangeToInclusive<I> as IdxSliceIndex<I, T>>::Output

fn index_mut( self, slice: &mut IndexSlice<I, [T]>, ) -> &mut <RangeToInclusive<I> as IdxSliceIndex<I, T>>::Output

Implementors

impl<I, T> IdxSliceIndex<I, T> for I

where I: Idx,

type Output = T