pub fn split_inclusive_mut<F>(
		&mut self,
		pred: F,
	) -> SplitInclusiveMut<T, O, F>
	where
		F: FnMut(usize, &bool) -> bool,
	{
		SplitInclusiveMut::new(self.alias_mut(), pred)
	}
/// Iterates over mutable subslices separated by bits that match a
/// predicate. Unlike `.split_mut()`, this *does* include the matching bit
/// as the last bit in the bit-slice.
///
/// Iterators do not require that each yielded item is destroyed before the
/// next is produced. This means that each bit-slice yielded must be marked
/// as aliased. If you are using this in a loop that does not collect
/// multiple yielded subslices for the same scope, then you can remove the
/// alias marking by calling the (`unsafe`) method [`.remove_alias()`] on
/// the iterator.
///
/// ## Original
///
/// [`slice::split_inclusive_mut`](https://doc.rust-lang.org/std/primitive.slice.html#method.split_inclusive_mut)
///
/// ## API Differences
///
/// The predicate function receives the index being tested as well as the
/// bit value at that index. This allows the predicate to have more than one
/// bit of information about the bit-slice being traversed.
///
/// ## Sibling Methods
///
/// - [`.split_inclusive()`] has the same splitting logic, but each yielded
///   bit-slice is immutable.
/// - [`.split_mut()`] does not include the matched bit in the yielded
///   bit-slice.
///
/// ## Examples
///
/// ```rust
/// use bitvec::prelude::*;
///
/// let bits = bits![mut 0, 0, 0, 0, 0];
/// //                         ^
/// for group in bits.split_inclusive_mut(|pos, _bit| pos % 3 == 2) {
///   group.set(0, true);
/// }
/// assert_eq!(bits, bits![1, 0, 0, 1, 0]);
/// ```
///
/// [`.remove_alias()`]: crate::slice::SplitInclusiveMut::remove_alias
/// [`.split_inclusive()`]: Self::split_inclusive
/// [`.split_mut()`]: Self::split_mut
Iterates over mutable subslices separated by bits that match a
predicate. Unlike `.split_mut()`, this *does* include the matching bit
as the last bit in the bit-slice.

Iterators do not require that each yielded item is destroyed before the
next is produced. This means that each bit-slice yielded must be marked
as aliased. If you are using this in a loop that does not collect
multiple yielded subslices for the same scope, then you can remove the
alias marking by calling the (`unsafe`) method [`.remove_alias()`] on
the iterator.
Iterates over mutable subslices separated by bits that match a predicate . Unlike ` . split_mut () ` this * does * include the matching bit as the last bit in the bit - slice . Iterators do not require that each yielded item is destroyed before the next is produced . This means that each bit - slice yielded must be marked as aliased . If you are using this in a loop that does not collect multiple yielded subslices for the same scope then you can remove the alias marking by calling the ( ` unsafe ` ) method [ ` . remove_alias () ` ] on the iterator .
pub fn split_inclusive_mut<F>(
		&mut self,
		pred: F,
	) -> SplitInclusiveMut<T, O, F>
	where
		F: FnMut(usize, &bool) -> bool,
	{
		SplitInclusiveMut::new(self.alias_mut(), pred)
	}
pub fn split_inclusive_mut < F > ( & mut self , pred : F , ) -> SplitInclusiveMut < T , O , F > where F : FnMut ( usize , & bool ) -> bool , { SplitInclusiveMut :: new ( self . alias_mut ( ) , pred ) }
Iterates over mutable subslices separated by bits that match a
predicate.
Iterates over mutable subslices separated by bits that match a predicate .
&mut self
pred
F
&mut self
pred
F
original
None
api differences
The predicate function receives the index being tested as well as the
bit value at that index. This allows the predicate to have more than one
bit of information about the bit-slice being traversed.
The predicate function receives the index being tested as well as the bit value at that index . This allows the predicate to have more than one bit of information about the bit - slice being traversed .
sibling methods
[`.split_inclusive()`] has the same splitting logic, but each yielded
bit-slice is immutable.
[`.split_mut()`] does not include the matched bit in the yielded
bit-slice.
[ ` . split_inclusive () ` ] has the same splitting logic but each yielded bit - slice is immutable . [ ` . split_mut () ` ] does not include the matched bit in the yielded bit - slice .
examples
```rust
use bitvec::prelude::*.



[`.remove_alias()`]: crate::slice::SplitInclusiveMut::remove_alias
[`.split_inclusive()`]: Self::split_inclusive
[`.split_mut()`]: Self::split_mut
` ` ` rust use bitvec :: prelude :: * . [ ` . remove_alias () ` ] : crate :: slice :: SplitInclusiveMut :: remove_alias [ ` . split_inclusive () ` ] : Self :: split_inclusive [ ` . split_mut () ` ] : Self :: split_mut