Struct SliceIter 

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

🔄 🍃 A lending iterator over a shared slice.

---

^{📍 sys/mem/view}

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

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

---

Yields elements by reference in index order. Produces &T without copying.

Implementations

impl<'s, T> SliceIter<'s, T>

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

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

Trait Implementations

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

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

Formats the value using the given formatter.

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

type Item<'a> = &'a 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 SliceIter<'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 SliceIter<'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.

impl<'s, T> IteratorLendingPeek for SliceIter<'s, T>

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

Returns the next item without advancing the iterator.

fn next_if<F>(&mut self, pred: F) -> Option<Self::Item<'_>>

where for<'a> F: FnOnce(&Self::Item<'a>) -> bool,

Returns the next item if it matches the predicate.

fn next_if_eq<Q>(&mut self, expected: &Q) -> Option<Self::Item<'_>>

where for<'a> Self::Item<'a>: PartialEq<Q>, Q: ?Sized,

Returns the next item if it is equal to expected.

fn next_if_map<R, E, F>(&mut self, f: F) -> Result<Option<R>, E>

where F: FnOnce(&Self::Item<'_>) -> Result<R, E>,

Applies f to the next item without advancing the iterator unless f returns Ok.