Struct otter::imports::IndexSlice
source · [−]#[repr(transparent)]pub struct IndexSlice<I, T> where
I: Idx,
T: ?Sized, {
pub raw: T,
/* private fields */
}
Expand description
A slice that only accepts indices of a specific type. Note that the intended
usage is as IndexSlice<I, [T]>
.
This is a thin wrapper around a [T]
, to the point where the backing is a
public property (called raw
). This is in part because I know this API is
not a complete mirror of Vec’s (patches welcome). In the worst case, you can
always do what you need to the slice itself.
Some notes on the APIs
-
Most of the Slice APIs are present.
- Any that aren’t can be trivially accessed on the underlying
raw
field, which is public.
- Any that aren’t can be trivially accessed on the underlying
-
Apis that take or return usizes referring to the positions of items were replaced with ones that take Idx.
-
Apis that take
R: RangeBounds<usize>
take anIdxRangeBounds<I>
, which is basically aRangeBounds<I>
. -
Apis that take
SliceIndex<usize>
take anIdxSliceIndex<I>
, which is basically aSliceIndex<I>
. -
Most iterator functions where
the_iter().enumerate()
would refer to indices have been given_enumerated
variants. E.g.IndexSlice::iter_enumerated
, etc. This is becausev.iter().enumerate()
would be(usize, &T)
, but you want(I, &T)
.
The following extensions are added:
IndexSlice::indices
: an Iterator over the indices of typeI
.- Various
enumerated
iterators mentioned earlier IndexSlice::position
,IndexSlice::rposition
asself.iter().position()
will return aOption<usize>
Fields
raw: T
Implementations
sourceimpl<I, T> IndexSlice<I, [T]> where
I: Idx,
impl<I, T> IndexSlice<I, [T]> where
I: Idx,
sourcepub fn new<S>(s: &S) -> &IndexSlice<I, [T]> where
S: AsRef<[T]> + ?Sized,
pub fn new<S>(s: &S) -> &IndexSlice<I, [T]> where
S: AsRef<[T]> + ?Sized,
Construct a new IdxSlice by wrapping an existing slice.
sourcepub fn new_mut<S>(s: &mut S) -> &mut IndexSlice<I, [T]> where
S: AsMut<[T]> + ?Sized,
pub fn new_mut<S>(s: &mut S) -> &mut IndexSlice<I, [T]> where
S: AsMut<[T]> + ?Sized,
Construct a new mutable IdxSlice by wrapping an existing mutable slice.
sourcepub fn from_slice(s: &[T]) -> &IndexSlice<I, [T]>
pub fn from_slice(s: &[T]) -> &IndexSlice<I, [T]>
Construct a new IdxSlice by wrapping an existing slice.
sourcepub fn from_slice_mut(s: &mut [T]) -> &mut IndexSlice<I, [T]>
pub fn from_slice_mut(s: &mut [T]) -> &mut IndexSlice<I, [T]>
Construct a new mutable IdxSlice by wrapping an existing mutable slice.
sourcepub fn into_vec(self: Box<IndexSlice<I, [T]>, Global>) -> IndexVec<I, T>
pub fn into_vec(self: Box<IndexSlice<I, [T]>, Global>) -> IndexVec<I, T>
Converts self
into a vector without clones or allocation.
The resulting vector can be converted back into a box via
IndexVec<I, T>
’s into_boxed_slice
method.
sourcepub fn as_raw_slice_mut(&mut self) -> &mut [T]ⓘNotable traits for &mut [u8]impl<'_> Write for &mut [u8]impl<'_> Read for &[u8]
pub fn as_raw_slice_mut(&mut self) -> &mut [T]ⓘNotable traits for &mut [u8]impl<'_> Write for &mut [u8]impl<'_> Read for &[u8]
Returns the underlying slice.
sourcepub fn as_raw_slice(&self) -> &[T]ⓘNotable traits for &mut [u8]impl<'_> Write for &mut [u8]impl<'_> Read for &[u8]
pub fn as_raw_slice(&self) -> &[T]ⓘNotable traits for &mut [u8]impl<'_> Write for &mut [u8]impl<'_> Read for &[u8]
Returns the underlying slice.
sourcepub fn as_mut_ptr(&mut self) -> *mut T
pub fn as_mut_ptr(&mut self) -> *mut T
Returns an unsafe mutable pointer to the slice’s buffer.
sourcepub fn iter(&self) -> Iter<'_, T>ⓘNotable traits for Iter<'a, T>impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;
pub fn iter(&self) -> Iter<'_, T>ⓘNotable traits for Iter<'a, T>impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;
Get a iterator over reverences to our values.
See also IndexSlice::iter_enumerated
, which gives you indices (of the
correct type) as you iterate.
sourcepub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘNotable traits for IterMut<'a, T>impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T;
pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘNotable traits for IterMut<'a, T>impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T;
Get a iterator over mut reverences to our values.
See also IndexSlice::iter_mut_enumerated
, which gives you indices (of
the correct type) as you iterate.
sourcepub fn iter_enumerated(
&self
) -> Map<Enumerate<Iter<'_, T>>, fn((usize, &T)) -> (I, &T)>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn iter_enumerated(
&self
) -> Map<Enumerate<Iter<'_, T>>, fn((usize, &T)) -> (I, &T)>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Similar to self.iter().enumerate()
but with indices of I
and not
usize
.
sourcepub fn indices(&self) -> Map<Range<usize>, fn(usize) -> I>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn indices(&self) -> Map<Range<usize>, fn(usize) -> I>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Get an interator over all our indices.
sourcepub fn iter_mut_enumerated(
&mut self
) -> Map<Enumerate<IterMut<'_, T>>, fn((usize, &mut T)) -> (I, &mut T)>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn iter_mut_enumerated(
&mut self
) -> Map<Enumerate<IterMut<'_, T>>, fn((usize, &mut T)) -> (I, &mut T)>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Similar to self.iter_mut().enumerate()
but with indices of I
and not
usize
.
sourcepub fn sort_by<F>(&mut self, compare: F) where
F: for<'_, '_> FnMut(&T, &T) -> Ordering,
pub fn sort_by<F>(&mut self, compare: F) where
F: for<'_, '_> FnMut(&T, &T) -> Ordering,
Forwards to the slice’s sort_by
implementation.
sourcepub fn sort_by_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
pub fn sort_by_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
Forwards to the slice’s sort_by_key
implementation.
sourcepub fn sort_by_cached_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
pub fn sort_by_cached_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
Forwards to the slice’s sort_by_cached_key
implementation.
sourcepub fn sort_unstable(&mut self) where
T: Ord,
pub fn sort_unstable(&mut self) where
T: Ord,
Forwards to the slice’s sort_unstable
implementation.
sourcepub fn sort_unstable_by<F>(&mut self, compare: F) where
F: for<'_, '_> FnMut(&T, &T) -> Ordering,
pub fn sort_unstable_by<F>(&mut self, compare: F) where
F: for<'_, '_> FnMut(&T, &T) -> Ordering,
Forwards to the slice’s sort_unstable_by
implementation.
sourcepub fn sort_unstable_by_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
pub fn sort_unstable_by_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
Forwards to the slice’s sort_unstable_by_key
implementation.
sourcepub fn ends_with<S>(&self, needle: &S) -> bool where
S: AsRef<[T]> + ?Sized,
T: PartialEq<T>,
pub fn ends_with<S>(&self, needle: &S) -> bool where
S: AsRef<[T]> + ?Sized,
T: PartialEq<T>,
Forwards to the slice’s ends_with
implementation.
sourcepub fn starts_with<S>(&self, needle: &S) -> bool where
S: AsRef<[T]> + ?Sized,
T: PartialEq<T>,
pub fn starts_with<S>(&self, needle: &S) -> bool where
S: AsRef<[T]> + ?Sized,
T: PartialEq<T>,
Forwards to the slice’s starts_with
implementation.
sourcepub fn contains(&self, x: &T) -> bool where
T: PartialEq<T>,
pub fn contains(&self, x: &T) -> bool where
T: PartialEq<T>,
Forwards to the slice’s contains
implementation.
sourcepub fn binary_search(&self, value: &T) -> Result<I, I> where
T: Ord,
pub fn binary_search(&self, value: &T) -> Result<I, I> where
T: Ord,
Call slice::binary_search
converting the indices it gives us back as
needed.
sourcepub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<I, I> where
F: FnMut(&'a T) -> Ordering,
pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<I, I> where
F: FnMut(&'a T) -> Ordering,
Binary searches this sorted vec with a comparator function, converting the indices it gives us back to our Idx type.
sourcepub fn copy_from_slice(&mut self, src: &IndexSlice<I, [T]>) where
T: Copy,
pub fn copy_from_slice(&mut self, src: &IndexSlice<I, [T]>) where
T: Copy,
Copies all elements from src
into self
, using a memcpy.
sourcepub fn clone_from_slice(&mut self, src: &IndexSlice<I, [T]>) where
T: Clone,
pub fn clone_from_slice(&mut self, src: &IndexSlice<I, [T]>) where
T: Clone,
Copies the elements from src
into self
.
sourcepub fn swap_with_slice(&mut self, other: &mut IndexSlice<I, [T]>)
pub fn swap_with_slice(&mut self, other: &mut IndexSlice<I, [T]>)
Swaps all elements in self
with those in other
.
sourcepub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<I, I> where
B: Ord,
F: FnMut(&'a T) -> B,
pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<I, I> where
B: Ord,
F: FnMut(&'a T) -> B,
Binary searches this sorted vec with a key extraction function, converting the indices it gives us back to our Idx type.
sourcepub fn position<F>(&self, f: F) -> Option<I> where
F: for<'_> FnMut(&T) -> bool,
pub fn position<F>(&self, f: F) -> Option<I> where
F: for<'_> FnMut(&T) -> bool,
Searches for an element in an iterator, returning its index. This is
equivalent to Iterator::position
, but returns I
and not usize
.
sourcepub fn rposition<F>(&self, f: F) -> Option<I> where
F: for<'_> FnMut(&T) -> bool,
pub fn rposition<F>(&self, f: F) -> Option<I> where
F: for<'_> FnMut(&T) -> bool,
Searches for an element in an iterator from the right, returning its
index. This is equivalent to Iterator::position
, but returns I
and
not usize
.
sourcepub fn split_at(&self, a: I) -> (&IndexSlice<I, [T]>, &IndexSlice<I, [T]>)
pub fn split_at(&self, a: I) -> (&IndexSlice<I, [T]>, &IndexSlice<I, [T]>)
Divides our slice into two at an index.
sourcepub fn split_at_mut(
&mut self,
a: I
) -> (&mut IndexSlice<I, [T]>, &mut IndexSlice<I, [T]>)
pub fn split_at_mut(
&mut self,
a: I
) -> (&mut IndexSlice<I, [T]>, &mut IndexSlice<I, [T]>)
Divides our slice into two at an index.
sourcepub fn rotate_left(&mut self, mid: I)
pub fn rotate_left(&mut self, mid: I)
Rotates our data in-place such that the first mid
elements of the
slice move to the end while the last self.len() - mid
elements move to
the front
sourcepub fn rotate_right(&mut self, k: I)
pub fn rotate_right(&mut self, k: I)
Rotates our data in-place such that the first self.len() - k
elements
of the slice move to the end while the last k
elements move to the
front
sourcepub fn first_mut(&mut self) -> Option<&mut T>
pub fn first_mut(&mut self) -> Option<&mut T>
Return the the first element, if we are not empty.
sourcepub fn copy_within<R>(&mut self, src: R, dst: I) where
R: IdxRangeBounds<I>,
T: Copy,
pub fn copy_within<R>(&mut self, src: R, dst: I) where
R: IdxRangeBounds<I>,
T: Copy,
Copies elements from one part of the slice to another part of itself, using a memmove.
sourcepub fn get<J>(&self, index: J) -> Option<&<J as IdxSliceIndex<I, T>>::Output> where
J: IdxSliceIndex<I, T>,
pub fn get<J>(&self, index: J) -> Option<&<J as IdxSliceIndex<I, T>>::Output> where
J: IdxSliceIndex<I, T>,
Get a ref to the item at the provided index, or None for out of bounds.
sourcepub fn get_mut<J>(
&mut self,
index: J
) -> Option<&mut <J as IdxSliceIndex<I, T>>::Output> where
J: IdxSliceIndex<I, T>,
pub fn get_mut<J>(
&mut self,
index: J
) -> Option<&mut <J as IdxSliceIndex<I, T>>::Output> where
J: IdxSliceIndex<I, T>,
Get a mut ref to the item at the provided index, or None for out of bounds
sourcepub fn windows(
&self,
size: usize
) -> Map<Windows<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn windows(
&self,
size: usize
) -> Map<Windows<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s windows
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn chunks(
&self,
size: usize
) -> Map<Chunks<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn chunks(
&self,
size: usize
) -> Map<Chunks<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s chunks
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn chunks_mut(
&mut self,
size: usize
) -> Map<ChunksMut<'_, T>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn chunks_mut(
&mut self,
size: usize
) -> Map<ChunksMut<'_, T>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s chunks_mut
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn chunks_exact(
&self,
chunk_size: usize
) -> Map<ChunksExact<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn chunks_exact(
&self,
chunk_size: usize
) -> Map<ChunksExact<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s chunks_exact
iterator with one that
yields IndexSlice
s with the correct index type.
sourcepub fn chunks_exact_mut(
&mut self,
chunk_size: usize
) -> Map<ChunksExactMut<'_, T>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn chunks_exact_mut(
&mut self,
chunk_size: usize
) -> Map<ChunksExactMut<'_, T>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s chunks_exact_mut
iterator with one that
yields IndexSlice
s with the correct index type.
sourcepub fn rchunks(
&self,
size: usize
) -> Map<RChunks<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn rchunks(
&self,
size: usize
) -> Map<RChunks<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rchunks
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn rchunks_mut(
&mut self,
size: usize
) -> Map<RChunksMut<'_, T>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn rchunks_mut(
&mut self,
size: usize
) -> Map<RChunksMut<'_, T>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rchunks_mut
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn rchunks_exact(
&self,
chunk_size: usize
) -> Map<RChunksExact<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn rchunks_exact(
&self,
chunk_size: usize
) -> Map<RChunksExact<'_, T>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rchunks_exact
iterator with one that
yields IndexSlice
s with the correct index type.
sourcepub fn rchunks_exact_mut(
&mut self,
chunk_size: usize
) -> Map<RChunksExactMut<'_, T>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
pub fn rchunks_exact_mut(
&mut self,
chunk_size: usize
) -> Map<RChunksExactMut<'_, T>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rchunks_exact_mut
iterator with one that
yields IndexSlice
s with the correct index type.
sourcepub fn split<F>(
&self,
f: F
) -> Map<Split<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
pub fn split<F>(
&self,
f: F
) -> Map<Split<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s split
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn split_mut<F>(
&mut self,
f: F
) -> Map<SplitMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
pub fn split_mut<F>(
&mut self,
f: F
) -> Map<SplitMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s split_mut
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn rsplit<F>(
&self,
f: F
) -> Map<RSplit<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
pub fn rsplit<F>(
&self,
f: F
) -> Map<RSplit<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rsplit
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn rsplit_mut<F>(
&mut self,
f: F
) -> Map<RSplitMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
pub fn rsplit_mut<F>(
&mut self,
f: F
) -> Map<RSplitMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rsplit_mut
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn splitn<F>(
&self,
n: usize,
f: F
) -> Map<SplitN<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
pub fn splitn<F>(
&self,
n: usize,
f: F
) -> Map<SplitN<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s splitn
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn splitn_mut<F>(
&mut self,
n: usize,
f: F
) -> Map<SplitNMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
pub fn splitn_mut<F>(
&mut self,
n: usize,
f: F
) -> Map<SplitNMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s splitn_mut
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn rsplitn<F>(
&self,
n: usize,
f: F
) -> Map<RSplitN<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
pub fn rsplitn<F>(
&self,
n: usize,
f: F
) -> Map<RSplitN<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rsplitn
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub fn rsplitn_mut<F>(
&mut self,
n: usize,
f: F
) -> Map<RSplitNMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
pub fn rsplitn_mut<F>(
&mut self,
n: usize,
f: F
) -> Map<RSplitNMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>impl<B, I, F> Iterator for Map<I, F> where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rsplitn_mut
iterator with one that yields
IndexSlice
s with the correct index type.
sourcepub unsafe fn from_raw_parts<'a>(
data: *const T,
len: usize
) -> &'a IndexSlice<I, [T]>
pub unsafe fn from_raw_parts<'a>(
data: *const T,
len: usize
) -> &'a IndexSlice<I, [T]>
Create a IdxSlice from its pointer and length.
Safety
This is equivalent to core::slice::from_raw_parts
and has the same
safety caveats.
sourcepub unsafe fn from_raw_parts_mut<'a>(
data: *mut T,
len: usize
) -> &'a mut IndexSlice<I, [T]>
pub unsafe fn from_raw_parts_mut<'a>(
data: *mut T,
len: usize
) -> &'a mut IndexSlice<I, [T]>
Create a mutable IdxSlice from its pointer and length.
Safety
This is equivalent to core::slice::from_raw_parts_mut
and has the same
safety caveats.
sourcepub fn split_first(&self) -> Option<(&T, &IndexSlice<I, [T]>)>
pub fn split_first(&self) -> Option<(&T, &IndexSlice<I, [T]>)>
Returns the first and all the rest of the elements of the slice, or None
if it is empty.
sourcepub fn split_first_mut(&mut self) -> Option<(&mut T, &mut IndexSlice<I, [T]>)>
pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut IndexSlice<I, [T]>)>
Returns the first and all the rest of the elements of the slice, or None
if it is empty.
sourcepub fn split_last(&self) -> Option<(&T, &IndexSlice<I, [T]>)>
pub fn split_last(&self) -> Option<(&T, &IndexSlice<I, [T]>)>
Returns the last and all the rest of the elements of the slice, or None
if it is empty.
sourcepub fn split_last_mut(&mut self) -> Option<(&mut T, &mut IndexSlice<I, [T]>)>
pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut IndexSlice<I, [T]>)>
Returns the last and all the rest of the elements of the slice, or None
if it is empty.
Trait Implementations
sourceimpl<I, A> AsMut<IndexSlice<I, [A]>> for IndexVec<I, A> where
I: Idx,
impl<I, A> AsMut<IndexSlice<I, [A]>> for IndexVec<I, A> where
I: Idx,
sourcefn as_mut(&mut self) -> &mut IndexSlice<I, [A]>
fn as_mut(&mut self) -> &mut IndexSlice<I, [A]>
Converts this type into a mutable reference of the (usually inferred) input type.
sourceimpl<I, A> AsRef<IndexSlice<I, [A]>> for IndexVec<I, A> where
I: Idx,
impl<I, A> AsRef<IndexSlice<I, [A]>> for IndexVec<I, A> where
I: Idx,
sourcefn as_ref(&self) -> &IndexSlice<I, [A]>
fn as_ref(&self) -> &IndexSlice<I, [A]>
Converts this type into a shared reference of the (usually inferred) input type.
sourceimpl<I, T> Borrow<IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
impl<I, T> Borrow<IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
sourcefn borrow(&self) -> &IndexSlice<I, [T]>
fn borrow(&self) -> &IndexSlice<I, [T]>
Immutably borrows from an owned value. Read more
sourceimpl<I, T> BorrowMut<IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
impl<I, T> BorrowMut<IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
sourcefn borrow_mut(&mut self) -> &mut IndexSlice<I, [T]>
fn borrow_mut(&mut self) -> &mut IndexSlice<I, [T]>
Mutably borrows from an owned value. Read more
sourceimpl<I, T> Clone for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
T: Clone,
impl<I, T> Clone for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
T: Clone,
sourcefn clone(&self) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn clone(&self) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl<I, T> Clone for IndexSlice<I, T> where
I: Clone + Idx,
T: Clone + ?Sized,
impl<I, T> Clone for IndexSlice<I, T> where
I: Clone + Idx,
T: Clone + ?Sized,
sourcefn clone(&self) -> IndexSlice<I, T>
fn clone(&self) -> IndexSlice<I, T>
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl<'_, I, T> Default for &IndexSlice<I, [T]> where
I: Idx,
impl<'_, I, T> Default for &IndexSlice<I, [T]> where
I: Idx,
sourcefn default() -> &IndexSlice<I, [T]>
fn default() -> &IndexSlice<I, [T]>
Returns the “default value” for a type. Read more
sourceimpl<I, A> Default for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
impl<I, A> Default for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
sourcefn default() -> Box<IndexSlice<I, [A]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn default() -> Box<IndexSlice<I, [A]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Returns the “default value” for a type. Read more
sourceimpl<'_, I, T> Default for &mut IndexSlice<I, [T]> where
I: Idx,
impl<'_, I, T> Default for &mut IndexSlice<I, [T]> where
I: Idx,
sourcefn default() -> &mut IndexSlice<I, [T]>
fn default() -> &mut IndexSlice<I, [T]>
Returns the “default value” for a type. Read more
sourceimpl<'de, I, T> Deserialize<'de> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
T: Deserialize<'de>,
impl<'de, I, T> Deserialize<'de> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
T: Deserialize<'de>,
sourcefn deserialize<D>(
deserializer: D
) -> Result<Box<IndexSlice<I, [T]>, Global>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D
) -> Result<Box<IndexSlice<I, [T]>, Global>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
sourceimpl<'a, I, T> From<&'a [T]> for &'a IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> From<&'a [T]> for &'a IndexSlice<I, [T]> where
I: Idx,
sourcefn from(a: &'a [T]) -> &'a IndexSlice<I, [T]>
fn from(a: &'a [T]) -> &'a IndexSlice<I, [T]>
Converts to this type from the input type.
sourceimpl<'a, I, T> From<&'a IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
T: Clone,
impl<'a, I, T> From<&'a IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
T: Clone,
sourcefn from(src: &'a IndexSlice<I, [T]>) -> IndexVec<I, T>
fn from(src: &'a IndexSlice<I, [T]>) -> IndexVec<I, T>
Converts to this type from the input type.
sourceimpl<'a, I, T> From<&'a mut [T]> for &'a mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> From<&'a mut [T]> for &'a mut IndexSlice<I, [T]> where
I: Idx,
sourcefn from(a: &'a mut [T]) -> &'a mut IndexSlice<I, [T]>
fn from(a: &'a mut [T]) -> &'a mut IndexSlice<I, [T]>
Converts to this type from the input type.
sourceimpl<'a, I, T> From<&'a mut IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
T: Clone,
impl<'a, I, T> From<&'a mut IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
T: Clone,
sourcefn from(src: &'a mut IndexSlice<I, [T]>) -> IndexVec<I, T>
fn from(src: &'a mut IndexSlice<I, [T]>) -> IndexVec<I, T>
Converts to this type from the input type.
sourceimpl<I, T> From<Box<[T], Global>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
impl<I, T> From<Box<[T], Global>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
sourcefn from(b: Box<[T], Global>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(b: Box<[T], Global>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts to this type from the input type.
sourceimpl<I, T> From<IndexVec<I, T>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
impl<I, T> From<IndexVec<I, T>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
sourcefn from(src: IndexVec<I, T>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(src: IndexVec<I, T>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts to this type from the input type.
sourceimpl<I, A> FromIterator<A> for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
impl<I, A> FromIterator<A> for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
sourcefn from_iter<T>(iter: T) -> Box<IndexSlice<I, [A]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
where
T: IntoIterator<Item = A>,
fn from_iter<T>(iter: T) -> Box<IndexSlice<I, [A]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
where
T: IntoIterator<Item = A>,
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Creates a value from an iterator. Read more
sourceimpl<I, R, T> Index<R> for IndexSlice<I, [T]> where
I: Idx,
R: IdxSliceIndex<I, T>,
impl<I, R, T> Index<R> for IndexSlice<I, [T]> where
I: Idx,
R: IdxSliceIndex<I, T>,
type Output = <R as IdxSliceIndex<I, T>>::Output
type Output = <R as IdxSliceIndex<I, T>>::Output
The returned type after indexing.
sourcefn index(&self, index: R) -> &<R as IdxSliceIndex<I, T>>::Output
fn index(&self, index: R) -> &<R as IdxSliceIndex<I, T>>::Output
Performs the indexing (container[index]
) operation. Read more
sourceimpl<I, R, T> IndexMut<R> for IndexSlice<I, [T]> where
I: Idx,
R: IdxSliceIndex<I, T>,
impl<I, R, T> IndexMut<R> for IndexSlice<I, [T]> where
I: Idx,
R: IdxSliceIndex<I, T>,
sourcefn index_mut(&mut self, index: R) -> &mut <R as IdxSliceIndex<I, T>>::Output
fn index_mut(&mut self, index: R) -> &mut <R as IdxSliceIndex<I, T>>::Output
Performs the mutable indexing (container[index]
) operation. Read more
sourceimpl<'a, I, T> IntoIterator for &'a mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a mut IndexSlice<I, [T]> where
I: Idx,
sourceimpl<'a, I, T> IntoIterator for &'a IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a IndexSlice<I, [T]> where
I: Idx,
sourceimpl<I, A> IntoIterator for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
impl<I, A> IntoIterator for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
type Item = A
type Item = A
The type of the elements being iterated over.
sourcefn into_iter(
self
) -> <Box<IndexSlice<I, [A]>, Global> as IntoIterator>::IntoIterⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn into_iter(
self
) -> <Box<IndexSlice<I, [A]>, Global> as IntoIterator>::IntoIterⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Creates an iterator from a value. Read more
sourceimpl<I, T> Ord for IndexSlice<I, [T]> where
I: Idx,
T: Ord,
impl<I, T> Ord for IndexSlice<I, [T]> where
I: Idx,
T: Ord,
sourceimpl<'a, 'b, A, B, I, J> PartialEq<&'a IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<&'a IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I, J> PartialEq<&'a mut IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<&'a mut IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 0]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 0]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 1]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 1]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 10]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 10]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 11]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 11]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 12]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 12]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 13]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 13]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 14]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 14]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 15]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 15]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 16]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 16]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 17]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 17]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 18]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 18]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 19]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 19]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 2]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 2]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 20]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 20]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 21]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 21]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 22]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 22]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 23]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 23]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 24]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 24]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 25]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 25]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 26]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 26]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 27]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 27]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 28]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 28]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 29]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 29]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 3]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 3]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 30]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 30]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 31]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 31]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 32]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 32]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 4]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 4]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 5]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 5]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 6]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 6]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 7]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 7]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 8]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 8]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 9]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 9]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I, J> PartialEq<&'b IndexSlice<J, [B]>> for IndexVec<I, A> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<&'b IndexSlice<J, [B]>> for IndexVec<I, A> where
I: Idx,
J: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b mut [B]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b mut [B]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I, J> PartialEq<&'b mut IndexSlice<J, [B]>> for IndexVec<I, A> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<&'b mut IndexSlice<J, [B]>> for IndexVec<I, A> where
I: Idx,
J: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 10]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 10]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 11]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 11]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 12]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 12]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 13]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 13]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 14]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 14]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 15]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 15]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 16]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 16]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 17]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 17]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 18]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 18]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 19]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 19]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 20]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 20]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 21]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 21]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 22]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 22]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 23]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 23]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 24]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 24]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 25]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 25]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 26]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 26]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 27]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 27]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 28]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 28]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 29]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 29]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 30]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 30]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 31]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 31]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<[B; 32]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<[B; 32]> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<I, A, B> PartialEq<IndexSlice<I, [B]>> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<I, A, B> PartialEq<IndexSlice<I, [B]>> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a mut IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a mut IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a mut IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a mut IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
sourceimpl<I, T> PartialOrd<IndexSlice<I, [T]>> for IndexSlice<I, [T]> where
I: Idx,
T: PartialOrd<T>,
impl<I, T> PartialOrd<IndexSlice<I, [T]>> for IndexSlice<I, [T]> where
I: Idx,
T: PartialOrd<T>,
sourcefn partial_cmp(&self, other: &IndexSlice<I, [T]>) -> Option<Ordering>
fn partial_cmp(&self, other: &IndexSlice<I, [T]>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl<I, T> Serialize for Box<IndexSlice<I, T>, Global> where
I: Idx,
T: Serialize,
impl<I, T> Serialize for Box<IndexSlice<I, T>, Global> where
I: Idx,
T: Serialize,
sourcefn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
Serialize this value into the given Serde serializer. Read more
sourceimpl<I, T> ToOwned for IndexSlice<I, [T]> where
I: Idx,
T: Clone,
impl<I, T> ToOwned for IndexSlice<I, [T]> where
I: Idx,
T: Clone,
impl<I, T> Copy for IndexSlice<I, T> where
I: Copy + Idx,
T: Copy + ?Sized,
impl<I, A> Eq for IndexSlice<I, [A]> where
I: Idx,
A: Eq,
impl<I, T> Send for IndexSlice<I, [T]> where
I: Idx,
T: Send,
Auto Trait Implementations
impl<I, T: ?Sized> RefUnwindSafe for IndexSlice<I, T> where
T: RefUnwindSafe,
impl<I, T: ?Sized> Send for IndexSlice<I, T> where
T: Send,
impl<I, T: ?Sized> Sync for IndexSlice<I, T> where
T: Sync,
impl<I, T: ?Sized> Unpin for IndexSlice<I, T> where
T: Unpin,
impl<I, T: ?Sized> UnwindSafe for IndexSlice<I, T> where
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: Any,
sourcefn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
sourcefn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
sourcefn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
sourcefn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
sourceimpl<T> DowncastSync for T where
T: Any + Send + Sync,
impl<T> DowncastSync for T where
T: Any + Send + Sync,
sourceimpl<A> DynCastExt for A
impl<A> DynCastExt for A
sourcefn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
A: DynCastExtHelper<T>,
T: ?Sized,
fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
A: DynCastExtHelper<T>,
T: ?Sized,
Use this to cast from one trait object type to another. Read more
sourcefn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
T: ?Sized,
fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
T: ?Sized,
Use this to upcast a trait to one of its supertraits. Read more
sourcefn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
T: ?Sized,
fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
T: ?Sized,
sourcefn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more