Struct lazy_list::LazyList

pub struct LazyList<T, I> { /* private fields */ }

A lazily-populated list.

See the crate-level documentation for more information.

Implementations

impl<T, I> LazyList<T, I>

pub const fn new(iterator: I) -> LazyList<T, I>

Creates an LazyList from an iterator. The resulting LazyList conceptually contains the list of elements that the iterator would produce.

Equivalent to crate::IteratorLazyExt::collect_lazy.

pub fn num_cached(&self) -> usize

Returns the number of elements that have been produced and cached so far.

impl<'a, T: Send + Sync + 'a> LazyList<T, Box<dyn Iterator<Item = T> + Send + 'a>>

pub fn recursive<F: FnMut(&LazyListBoxed<'a, T>, usize) -> Option<T> + Send + 'a>( f: F ) -> Arc<LazyListBoxed<'a, T>>

Creates a recursively-defined LazyList. The closure should take a reference to the LazyList itself and an index, then return the element at that index, or None if there are no more elements. The closure should only attempt to access prior elements of the LazyList, or a deadlock will occur.

impl<'a, T, I: Iterator<Item = T> + Send + 'a> LazyList<T, I>

pub fn boxed(self) -> LazyListBoxed<'a, T>

Returns a boxed version of the LazyList. This is useful when you don’t want to write out the iterator type as a type parameter.

impl<T, I: Iterator<Item = T>> LazyList<T, I>

pub fn get(&self, index: usize) -> Option<&T>

Returns a reference to the element at index index, or None if the index is out of bounds.

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to the element at index index, or None if the index is out of bounds.

pub fn iter(&self) -> Iter<'_, T, I>

Returns an iterator over the elements of the LazyList.

pub fn iter_mut(&mut self) -> IterMut<'_, T, I>

Returns a mutable iterator over the elements of the LazyList.

Trait Implementations

impl<T: Debug, I> Debug for LazyList<T, I>

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

Formats the value using the given formatter.

impl<T, I: Iterator<Item = T>> Index<usize> for LazyList<T, I>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T, I: Iterator<Item = T>> IndexMut<usize> for LazyList<T, I>

fn index_mut(&mut self, index: usize) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<'a, T, I: Iterator<Item = T>> IntoIterator for &'a LazyList<T, I>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T, I>

Creates an iterator from a value.

impl<'a, T, I: Iterator<Item = T>> IntoIterator for &'a mut LazyList<T, I>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T, I>

Creates an iterator from a value.

impl<T, I: Iterator<Item = T>> IntoIterator for LazyList<T, I>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T, I>

Creates an iterator from a value.