[−][src]Struct core::slice::SplitInclusiveMut  
🔬 This is a nightly-only experimental API. (
split_inclusive)An iterator over the mutable subslices of the vector which are separated
by elements that match pred. Unlike SplitMut, it contains the matched
parts in the ends of the subslices.
This struct is created by the split_inclusive_mut method on slices.
Trait Implementations
impl<'_, T: Debug, P> Debug for SplitInclusiveMut<'_, T, P> where
    P: FnMut(&T) -> bool, [src]
P: FnMut(&T) -> bool,
impl<'a, T, P> DoubleEndedIterator for SplitInclusiveMut<'a, T, P> where
    P: FnMut(&T) -> bool, [src]
P: FnMut(&T) -> bool,
fn next_back(&mut self) -> Option<&'a mut [T]>[src]
fn nth_back(&mut self, n: usize) -> Option<Self::Item>1.37.0[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Ok = B>, 1.27.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn rfold<B, F>(self, accum: B, f: F) -> B where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B, 1.27.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.27.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
impl<'_, T, P> FusedIterator for SplitInclusiveMut<'_, T, P> where
    P: FnMut(&T) -> bool, [src]
P: FnMut(&T) -> bool,
impl<'a, T, P> Iterator for SplitInclusiveMut<'a, T, P> where
    P: FnMut(&T) -> bool, [src]
P: FnMut(&T) -> bool,
type Item = &'a mut [T]
The type of the elements being iterated over.
fn next(&mut self) -> Option<&'a mut [T]>[src]
fn size_hint(&self) -> (usize, Option<usize>)[src]
fn count(self) -> usize where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn last(self) -> Option<Self::Item> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn nth(&mut self, n: usize) -> Option<Self::Item>1.0.0[src]
fn step_by(self, step: usize) -> StepBy<Self> where
    Self: Sized, 1.28.0[src]
Self: Sized,
fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where
    Self: Sized,
    U: IntoIterator<Item = Self::Item>, 1.0.0[src]
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where
    Self: Sized,
    U: IntoIterator, 1.0.0[src]
Self: Sized,
U: IntoIterator,
fn map<B, F>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> B, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
    Self: Sized,
    F: FnMut(Self::Item), 1.21.0[src]
Self: Sized,
F: FnMut(Self::Item),
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn peekable(self) -> Peekable<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
    Self: Sized,
    P: FnMut(Self::Item) -> Option<B>, [src]
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn skip(self, n: usize) -> Skip<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn take(self, n: usize) -> Take<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
    Self: Sized,
    F: FnMut(&mut St, Self::Item) -> Option<B>, 1.0.0[src]
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    Self: Sized,
    U: IntoIterator,
    F: FnMut(Self::Item) -> U, 1.0.0[src]
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flatten(self) -> Flatten<Self> where
    Self: Sized,
    Self::Item: IntoIterator, 1.29.0[src]
Self: Sized,
Self::Item: IntoIterator,
fn fuse(self) -> Fuse<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    Self: Sized,
    F: FnMut(&Self::Item), 1.0.0[src]
Self: Sized,
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 1.0.0[src]
Self: Sized,
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
fn collect<B: FromIterator<Self::Item>>(self) -> B where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn partition<B, F>(self, f: F) -> (B, B) where
    Self: Sized,
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T: 'a, P>(self, predicate: P) -> usize where
    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
    P: FnMut(&T) -> bool, [src]
Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
fn is_partitioned<P>(self, predicate: P) -> bool where
    Self: Sized,
    P: FnMut(Self::Item) -> bool, [src]
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Ok = B>, 1.27.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn try_for_each<F, R>(&mut self, f: F) -> R where
    Self: Sized,
    F: FnMut(Self::Item) -> R,
    R: Try<Ok = ()>, 1.27.0[src]
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn fold<B, F>(self, init: B, f: F) -> B where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B, 1.0.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn all<F>(&mut self, f: F) -> bool where
    Self: Sized,
    F: FnMut(Self::Item) -> bool, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
    Self: Sized,
    F: FnMut(Self::Item) -> bool, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>, 1.30.0[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn try_find<F, E, R>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
    Self: Sized,
    F: FnMut(&Self::Item) -> R,
    R: Try<Ok = bool, Error = E>, [src]
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
    Self: Sized,
    P: FnMut(Self::Item) -> bool, 1.0.0[src]
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool,
    Self: Sized + ExactSizeIterator + DoubleEndedIterator, 1.0.0[src]
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
    Self: Sized,
    Self::Item: Ord, 1.0.0[src]
Self: Sized,
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
    Self: Sized,
    Self::Item: Ord, 1.0.0[src]
Self: Sized,
Self::Item: Ord,
fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item) -> B, 1.6.0[src]
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item) -> B, 1.6.0[src]
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn rev(self) -> Rev<Self> where
    Self: Sized + DoubleEndedIterator, 1.0.0[src]
Self: Sized + DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Iterator<Item = (A, B)>, 1.0.0[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
fn copied<'a, T: 'a>(self) -> Copied<Self> where
    Self: Sized + Iterator<Item = &'a T>,
    T: Copy, 1.36.0[src]
Self: Sized + Iterator<Item = &'a T>,
T: Copy,
fn cloned<'a, T: 'a>(self) -> Cloned<Self> where
    Self: Sized + Iterator<Item = &'a T>,
    T: Clone, 1.0.0[src]
Self: Sized + Iterator<Item = &'a T>,
T: Clone,
fn cycle(self) -> Cycle<Self> where
    Self: Sized + Clone, 1.0.0[src]
Self: Sized + Clone,
fn sum<S>(self) -> S where
    Self: Sized,
    S: Sum<Self::Item>, 1.11.0[src]
Self: Sized,
S: Sum<Self::Item>,
fn product<P>(self) -> P where
    Self: Sized,
    P: Product<Self::Item>, 1.11.0[src]
Self: Sized,
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord,
    Self: Sized, 1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Self: Sized,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, I::Item) -> Ordering, [src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Ordering,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, I::Item) -> Option<Ordering>, [src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Option<Ordering>,
fn eq<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, I::Item) -> bool, [src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> bool,
fn ne<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn le<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn gt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn ge<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn is_sorted(self) -> bool where
    Self: Sized,
    Self::Item: PartialOrd, [src]
Self: Sized,
Self::Item: PartialOrd,
fn is_sorted_by<F>(self, compare: F) -> bool where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, [src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
    Self: Sized,
    F: FnMut(Self::Item) -> K,
    K: PartialOrd, [src]
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd,
Auto Trait Implementations
impl<'a, T, P> Send for SplitInclusiveMut<'a, T, P> where
    P: Send,
    T: Send, 
P: Send,
T: Send,
impl<'a, T, P> Sync for SplitInclusiveMut<'a, T, P> where
    P: Sync,
    T: Sync, 
P: Sync,
T: Sync,
impl<'a, T, P> Unpin for SplitInclusiveMut<'a, T, P> where
    P: Unpin, 
P: Unpin,
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
T: ?Sized,
fn borrow_mut(&mut Self) -> &mut T[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
U: TryFrom<T>,