pub fn rchunks_exact_mut(
		&mut self,
		chunk_size: usize,
	) -> RChunksExactMut<T, O> {
		RChunksExactMut::new(self, chunk_size)
	}
/// Iterates over non-overlapping mutable subslices of a bit-slice, from the
/// back edge.
///
/// If `self.len()` is not an even multiple of `chunk_size`, then the first
/// few bits are not yielded by the iterator at all. They can be accessed
/// with the [`.into_remainder()`] method if the iterator is bound to a
/// name.
///
/// 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.
///
/// ## Sibling Methods
///
/// - [`.rchunks_mut()`] yields any leftover bits at the front as a shorter
///   chunk during iteration.
/// - [`.rchunks_exact()`] has the same division logic, but each yielded
///   bit-slice is immutable.
/// - [`.chunks_exact_mut()`] iterates from the front of the bit-slice
///   backwards, with the unyielded remainder segment at the back edge.
///
/// ## Panics
///
/// This panics if `chunk_size` is `0`.
///
/// ## Examples
///
/// ```rust
/// use bitvec::prelude::*;
///
/// let bits = bits![mut u8, Msb0; 0; 5];
/// let mut iter = bits.rchunks_exact_mut(2);
///
/// for (idx, chunk) in iter.by_ref().enumerate() {
///   chunk.store(idx + 1);
/// }
/// iter.into_remainder().store(1u8);
///
/// assert_eq!(bits, bits![1, 1, 0, 0, 1]);
/// //           remainder ^
/// ```
///
/// [`.chunks_exact_mut()`]: Self::chunks_exact_mut
/// [`.into_remainder()`]: crate::slice::RChunksExactMut::into_remainder
/// [`.rchunks_exact()`]: Self::rchunks_exact
/// [`.rchunks_mut()`]: Self::rchunks_mut
/// [`.remove_alias()`]: crate::slice::RChunksExactMut::remove_alias
Iterates over non-overlapping mutable subslices of a bit-slice, from the
back edge.

If `self.len()` is not an even multiple of `chunk_size`, then the first
few bits are not yielded by the iterator at all. They can be accessed
with the [`.into_remainder()`] method if the iterator is bound to a
name.

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 non - overlapping mutable subslices of a bit - slice from the back edge . If ` self . len () ` is not an even multiple of ` chunk_size ` then the first few bits are not yielded by the iterator at all . They can be accessed with the [ ` . into_remainder () ` ] method if the iterator is bound to a name . 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 rchunks_exact_mut(
		&mut self,
		chunk_size: usize,
	) -> RChunksExactMut<T, O> {
		RChunksExactMut::new(self, chunk_size)
	}
pub fn rchunks_exact_mut ( & mut self , chunk_size : usize , ) -> RChunksExactMut < T , O > { RChunksExactMut :: new ( self , chunk_size ) }
Iterates over non-overlapping mutable subslices of a bit-slice, from the
back edge.
Iterates over non - overlapping mutable subslices of a bit - slice from the back edge .
&mut self
chunk_size
usize
&mut self
chunk_size
usize
sibling methods
[`.rchunks_mut()`] yields any leftover bits at the front as a shorter
chunk during iteration.
[`.rchunks_exact()`] has the same division logic, but each yielded
bit-slice is immutable.
[`.chunks_exact_mut()`] iterates from the front of the bit-slice
backwards, with the unyielded remainder segment at the back edge.
[ ` . rchunks_mut () ` ] yields any leftover bits at the front as a shorter chunk during iteration . [ ` . rchunks_exact () ` ] has the same division logic but each yielded bit - slice is immutable . [ ` . chunks_exact_mut () ` ] iterates from the front of the bit - slice backwards with the unyielded remainder segment at the back edge .
panics
This panics if `chunk_size` is `0`.
This panics if ` chunk_size ` is ` 0 ` .
examples
```rust
use bitvec::prelude::*.

let bits = bits![mut u8, Msb0; 0; 5];
let mut iter = bits.rchunks_exact_mut(2).

for (idx, chunk) in iter.by_ref().enumerate() {
chunk.store(idx + 1);
}
iter.into_remainder().store(1u8).




` ` ` rust use bitvec :: prelude :: * . let bits = bits! [ mut u8 Msb0 ; 0 ; 5 ] ; let mut iter = bits . rchunks_exact_mut ( 2 ) . for ( idx chunk ) in iter . by_ref () . enumerate () { chunk . store ( idx + 1 ) ; } iter . into_remainder () . store ( 1u8 ) .