Struct IntoStringIter 

pub struct IntoStringIter<Ctx, Seq, Err = Infallible> { /* private fields */ }

Turns a WritableSeq into an iterator over owned strings.

The iterator implementation calls InMemoryOutput::try_print_output for each writable produced by the sequence. It uses Rust’s async mechanics in order to invert control flow and produce lazy iteration, making sure to return complete futures from the crate::SequenceAccept when the iterator is ready to advance. However, this type expects a monopoly on such async control flow and may panic if extraneous async waiting is introduced.

Accordingly, this type is intended mainly for testing purposes, allowing the caller to check the output of their WritableSeq implementations.

Iteration and Errors

The default error type is no error (infallible). However, the caller can specify a different error type in accordance with InMemoryOutput.

If any of the writable values produces an error, it is returned instead of the string for that item in the iterator. However, if the sequence itself produces an error, then the iterator will produce an error as its final item and stop.

Panics

Iteration may panic if the sequence or any of its writable outputs returns a future that yields a pending poll based on external async computations (in particular, only pending polls caused by the iterative backpressure emitted from the crate::SequenceAccept implementation are allowed)

Implementations

impl<Ctx, Seq, Err> IntoStringIter<Ctx, Seq, Err>

pub fn new(context: Ctx, sequence: Seq) -> Self

Trait Implementations

impl<Ctx, Seq, Err> Clone for IntoStringIter<Ctx, Seq, Err>

where Ctx: Clone, Seq: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Ctx, Seq, Err> Debug for IntoStringIter<Ctx, Seq, Err>

where Ctx: Debug, Seq: Debug,

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

Formats the value using the given formatter.

impl<Ctx, Seq, Err> IntoIterator for IntoStringIter<Ctx, Seq, Err>

where Ctx: Context, Seq: WritableSeq<InMemoryOutput<Ctx, Err>>, Err: From<Infallible>,

type Item = Result<String, Err>

The type of the elements being iterated over.

type IntoIter = ToStringIter<Ctx, Seq, Err>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.