Struct SliceIterMut 

pub struct SliceIterMut<'s, T> { /* private fields */ }

🔄 🍃 A lending iterator over an exclusive slice.

---

^{📍 sys/mem/view}

^{📦 size_of::<SliceIterMut<'_, char>>() == 16 bytes / 128 bits #️⃣ #[cfg(target_pointer_width = “32”)]}

^{📦 size_of::<SliceIterMut<'_, char>>() == 32 bytes / 256 bits #️⃣ #[cfg(target_pointer_width = “64”)]}

---

Yields &mut T references in index order.

The returned reference is tied to the temporary mutable borrow of the iterator taken by next, matching the IteratorLending contract.

Examples

let mut array = [0, 1, 2, 3];
let mut it = SliceIterMut::new(&mut array);
while let Some(x) = it.next() {
    *x += 1;
}
assert_eq![array.as_slice(), &[1, 2, 3, 4]];

Implementations

impl<'s, T> SliceIterMut<'s, T>

pub fn new(slice: &'s mut [T]) -> Self

Creates an iterator over the given exclusive slice starting at index 0.

Trait Implementations

impl<'s, T: Debug> Debug for SliceIterMut<'s, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'s, T> IteratorLending for SliceIterMut<'s, T>

type Item<'a> = &'a mut T where Self: 'a

The item yielded by this iterator.

fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>

Advances the iterator and returns the next item.

fn size_hint(&self) -> (usize, Option<usize>)

Returns a size hint for the remaining items.

fn count(&mut self) -> usize

Consumes the iterator, returning the number of remaining items.

fn advance_by(&mut self, n: usize) -> Result<(), usize>

Advances the iterator by n steps.

fn nth<'a>(&'a mut self, n: usize) -> Option<Self::Item<'a>>

Advances the iterator by n items and returns the next one.

fn for_each<F>(&mut self, f: F)

where F: FnMut(Self::Item<'_>),

Applies f to each remaining item.

fn inspect<F>(&mut self, f: F)

where F: FnMut(&Self::Item<'_>),

Calls f for each item before yielding it.

fn is_partitioned<P>(&mut self, pred: P) -> bool

where P: FnMut(&Self::Item<'_>) -> bool,

Returns true if the iterator is partitioned according to pred.

fn try_fold<B, E, F>(&mut self, acc: B, f: F) -> Result<B, E>

where F: FnMut(B, Self::Item<'_>) -> Result<B, E>,

Applies f to each item, accumulating results in acc.

fn try_for_each<F, E>(&mut self, f: F) -> Result<(), E>

where F: FnMut(Self::Item<'_>) -> Result<(), E>,

Applies f to each remaining item until an error occurs.

fn all<P>(&mut self, pred: P) -> bool

where P: FnMut(&Self::Item<'_>) -> bool,

Returns true if all items satisfy the predicate.

fn any<P>(&mut self, pred: P) -> bool

where P: FnMut(&Self::Item<'_>) -> bool,

Returns true if any item satisfies the predicate.

fn position<P>(&mut self, pred: P) -> Option<usize>

where P: FnMut(&Self::Item<'_>) -> bool,

Returns the index of the first item for which pred returns true, or None if no matching item is found.

impl<'s, T> IteratorLendingDoubleEnded for SliceIterMut<'s, T>

fn next_back<'a>(&'a mut self) -> Option<Self::Item<'a>>

Returns the next item from the back of the iterator.

fn nth_back<'a>(&'a mut self, n: usize) -> Option<Self::Item<'a>>

Skips n items from the back and returns the next one.

fn try_rfold<B, E, F>(&mut self, acc: B, f: F) -> Result<B, E>

where F: FnMut(B, Self::Item<'_>) -> Result<B, E>,

Reverse-direction equivalent of IteratorLending::try_fold.

impl<'s, T> IteratorLendingExactSize for SliceIterMut<'s, T>

fn len(&self) -> usize

Returns the exact number of items remaining.

fn is_empty(&self) -> bool

Returns true when no more items can be produced.