async_codegen/

util.rs

/*
 * Copyright © 2025 Anand Beh
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use crate::common::SequenceConfig;
use crate::context::Context;
use crate::{IoOutput, Output, Writable, WritableSeq};
use std::convert::Infallible;
use std::fmt::Debug;
use std::marker::PhantomData;
use std::pin::pin;
use std::task::{Poll, Waker};

/// A wrapper intended to be used as a [SequenceConfig].
/// The tuple value should be a function that returns a writable for the data type.
pub struct WritableFromFunction<F>(pub F);

impl<F, T, W, O> SequenceConfig<T, O> for WritableFromFunction<F>
where
    O: Output,
    F: Fn(&T) -> W,
    W: Writable<O>,
{
    async fn write_datum(&self, datum: &T, output: &mut O) -> Result<(), O::Error> {
        let writable = (&self.0)(datum);
        writable.write_to(output).await
    }
}

/// An IO implementation that just writes to a string. The futures produced from methods
/// like [IoOutput::write] are complete instantly, and no errors are produced.
pub struct InMemoryIo<'s>(pub &'s mut String);

impl IoOutput for InMemoryIo<'_> {
    type Error = Infallible;

    async fn write(&mut self, value: &str) -> Result<(), Self::Error> {
        self.0.push_str(value);
        Ok(())
    }
}

/// An output implementation that just writes to a string.
///
/// This output itself produces no errors and the write futures complete instantly. It uses
/// [InMemoryIo] as the IO type.
///
/// However, for compatibility with higher level code that uses a different error type, the
/// error type can be selected by the type parameter `Err`. Note that `Err` must be convertible
/// from [Infallible]. Regardless of the error type chosen, it will never be returned from this
/// output itself.
pub struct InMemoryOutput<Ctx, Err = Infallible> {
    buf: String,
    context: Ctx,
    error_type: PhantomData<fn(Infallible) -> Err>,
}

impl<Ctx, Err> InMemoryOutput<Ctx, Err> {
    pub fn new(context: Ctx) -> Self {
        Self {
            buf: String::new(),
            context,
            error_type: PhantomData,
        }
    }
}

impl<Ctx, Err> Output for InMemoryOutput<Ctx, Err>
where
    Ctx: Context,
    Err: From<Infallible>,
{
    type Io<'b>
        = InMemoryIo<'b>
    where
        Self: 'b;
    type Ctx = Ctx;
    type Error = Err;

    async fn write(&mut self, value: &str) -> Result<(), Self::Error> {
        self.buf.push_str(value);
        Ok(())
    }

    fn split(&mut self) -> (Self::Io<'_>, &Self::Ctx) {
        (InMemoryIo(&mut self.buf), &self.context)
    }

    fn context(&self) -> &Self::Ctx {
        &self.context
    }
}

impl<Ctx, Err> InMemoryOutput<Ctx, Err>
where
    Ctx: Context,
    Err: From<Infallible>,
{
    /// Gets the string output of a single writable.
    ///
    /// Assumes that the only source of async is this [InMemoryOutput] itself, i.e. the writable
    /// will never return a pending future unless the output used with it returns a pending future.
    /// Because of its async-rejecting nature, this function is intended for testing purposes.
    ///
    /// **Panics** if the writable returns a pending future (particularly, this may happen if
    /// a writable introduces its own async computations that do not come from the output)
    pub fn try_print_output<W>(context: Ctx, writable: &W) -> Result<String, Err>
    where
        W: Writable<Self>,
    {
        let mut output = Self::new(context);
        let result = output.print_output_impl(writable);
        result.map(|()| output.buf)
    }

    fn print_output_impl<W>(&mut self, writable: &W) -> Result<(), Err>
    where
        W: Writable<Self>,
    {
        let future = pin!(writable.write_to(self));
        match future.poll(&mut std::task::Context::from_waker(Waker::noop())) {
            Poll::Pending => panic!("Expected a complete future"),
            Poll::Ready(result) => result,
        }
    }
}

impl<Ctx> InMemoryOutput<Ctx>
where
    Ctx: Context,
{
    /// Gets the string output of a single writable.
    ///
    /// Infallible version of [try_print_output]. See that function's documentation for
    /// full details.
    ///
    /// **Panics** if the writable returns a pending future (particularly, this may happen if
    /// a writable introduces its own async computations that do not come from the output)
    pub fn print_output<W>(context: Ctx, writable: &W) -> String
    where
        W: Writable<Self>,
    {
        Self::try_print_output(context, writable).unwrap_or_else(|e| match e {})
    }
}

/// 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)
///
pub struct IntoStringIter<Ctx, Seq, Err = Infallible> {
    context: Ctx,
    sequence: Seq,
    error_type: PhantomData<fn(Infallible) -> Err>,
}

impl<Ctx, Seq, Err> IntoStringIter<Ctx, Seq, Err> {
    pub fn new(context: Ctx, sequence: Seq) -> Self {
        Self {
            context,
            sequence,
            error_type: PhantomData,
        }
    }
}

impl<Ctx, Seq, Err> Clone for IntoStringIter<Ctx, Seq, Err>
where
    Ctx: Clone,
    Seq: Clone,
{
    fn clone(&self) -> Self {
        Self {
            context: self.context.clone(),
            sequence: self.sequence.clone(),
            error_type: PhantomData,
        }
    }
}

impl<Ctx, Seq, Err> Debug for IntoStringIter<Ctx, Seq, Err>
where
    Ctx: Debug,
    Seq: Debug,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("IntoStringIter")
            .field("context", &self.context)
            .field("sequence", &self.sequence)
            .field("error_type", &std::any::type_name::<Err>())
            .finish()
    }
}

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>;
    type IntoIter = ToStringIter<Ctx, Seq, Err>;
    fn into_iter(self) -> Self::IntoIter {
        ToStringIter(string_iter::StringIter::new(self.context, self.sequence))
    }
}

/// The iterator produced by [IntoStringIter].
pub struct ToStringIter<Ctx, Seq, Err = Infallible>(string_iter::StringIter<Ctx, Seq, Err>);

impl<Ctx, Seq, Err> Debug for ToStringIter<Ctx, Seq, Err>
where
    Err: Debug,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ToStringIter")
            .field("inner", &self.0)
            .finish()
    }
}

impl<Ctx, Seq, Err> Iterator for ToStringIter<Ctx, Seq, Err>
where
    Ctx: Context,
    Seq: WritableSeq<InMemoryOutput<Ctx, Err>>,
    Err: From<Infallible>,
{
    type Item = Result<String, Err>;
    fn next(&mut self) -> Option<Self::Item> {
        self.0.next()
    }
}

mod string_iter {
    use crate::context::Context;
    use crate::util::InMemoryOutput;
    use crate::{SequenceAccept, Writable, WritableSeq};
    use std::cell::UnsafeCell;
    use std::convert::Infallible;
    use std::fmt::Debug;
    use std::future::poll_fn;
    use std::marker::PhantomData;
    use std::mem::{ManuallyDrop, MaybeUninit};
    use std::ops::DerefMut;
    use std::pin::Pin;
    use std::ptr::NonNull;
    use std::task::{Poll, Waker};
    use std::{mem, ptr};

    pub struct StringIter<Ctx, Seq, Err> {
        // Reminds dropck that we manage this memory and drop it ourselves
        marker: PhantomData<(Ctx, Seq)>,
        inner: NonNull<Progressor<Ctx, Seq, Err>>,
        // If the sequence produced an error, sometimes we keep it until next() is called again
        // If Err = Infallible, a good compiler will optimize this field away
        seq_error_in_pipe: Option<Err>,
        finished: bool,
    }

    impl<Ctx, Seq, Err> Debug for StringIter<Ctx, Seq, Err>
    where
        Err: Debug,
    {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let inner = self.inner.as_ptr();
            let buffer = unsafe {
                // SAFETY
                // This value can be read from multiple places
                &*(&raw const (*inner).buffer)
            };
            f.debug_struct("StringIter")
                .field(
                    "marker",
                    &(&std::any::type_name::<Ctx>(), &std::any::type_name::<Seq>()),
                )
                .field("inner.buffer", buffer)
                .field("seq_error_in_pipe", &self.seq_error_in_pipe)
                .field("finished", &self.finished)
                .finish()
        }
    }

    impl<Ctx, Seq, Err> Drop for StringIter<Ctx, Seq, Err> {
        fn drop(&mut self) {
            Progressor::deallocate(self.inner)
        }
    }

    type Progressor<Ctx, Seq, Err> =
        RawProgressor<Ctx, Seq, Err, dyn Future<Output = Result<(), Err>>>;

    // A self-referential struct and DST.
    // We initialize it field-by-field, allowing us to use pointers to other parts
    // Once ready, we coerce to dyn Future to make this an unsized type
    struct RawProgressor<Ctx, Seq, Err, Fut: ?Sized> {
        // The one-item buffer is shared inside and outside the future
        buffer: ItemBuffer<Err>,
        // The storage for the context and sequence
        // Not to be touched! Fut takes permanent (mutable) references to what's inside
        vault: RawProgressorVault<Ctx, Seq, Err>,
        // DST-capable future. Contains references to:
        // 1. acceptor: &mut
        // 2. sequence: &
        // 3. buffer: *const (via acceptor)

        // This doesn't need to be ManuallyDrop if we can drop via pointer
        // Can remove this once #![feature(layout_for_ptr)] is stable
        future: ManuallyDrop<Fut>,
    }

    struct RawProgressorVault<Ctx, Seq, Err> {
        // Fut takes a permanent mutable reference to this field
        acceptor: SeqAccept<Ctx, Err>,
        // Also used by Fut, but immutable
        sequence: Seq,
    }

    impl<Ctx, Seq, Err> StringIter<Ctx, Seq, Err>
    where
        Ctx: Context,
        Seq: WritableSeq<InMemoryOutput<Ctx, Err>>,
        Err: From<Infallible>,
    {
        pub fn new(context: Ctx, sequence: Seq) -> Self {
            let ptr = Self::make_raw_progressor(context, sequence, |vault| {
                WritableSeq::for_each(&vault.sequence, &mut vault.acceptor)
            });
            Self {
                marker: PhantomData,
                inner: ptr,
                seq_error_in_pipe: None,
                finished: false,
            }
        }

        // Why use the following function

        // 1. Generic Inference
        // We need this function to allow generics to be inferred
        // Inference lets us work around WritableSeq::for_each returning an anonymous future

        // 2. Lifetime Hack
        // Although we know that Ctx, Seq outlive Self, the borrow checker often bitches about it
        // Somehow, this function gets rid of that limitation. Amazing stuff.
        fn make_raw_progressor<'f, MakeFut, Fut>(
            context: Ctx,
            sequence: Seq,
            make_fut: MakeFut,
        ) -> NonNull<Progressor<Ctx, Seq, Err>>
        where
            Fut: Future<Output = Result<(), Err>> + 'f,
            MakeFut: FnOnce(&'f mut RawProgressorVault<Ctx, Seq, Err>) -> Fut,
            Ctx: 'f,
            Seq: 'f,
            Err: 'f,
        {
            // First, allocate the whole RawProgressor onto the heap
            // This will allow us to use stable pointers everywhere (pinning, effectively)
            let allocated = Box::new(MaybeUninit::<RawProgressor<Ctx, Seq, Err, Fut>>::uninit());
            unsafe {
                // SAFETY
                // Initialize fields one-by-one
                // All of our pointers will be stable, because we put everything in a box
                let fields_ptr = Box::into_raw(allocated);
                let fields_ptr = (&mut *fields_ptr).as_mut_ptr();

                // We initialize the buffer here, then re-use the pointer later
                let buffer_ptr = &raw mut (*fields_ptr).buffer;
                ptr::write(buffer_ptr, ItemBuffer::default());

                // We initialize acceptor using the stable buffer pointer
                // We initialize sequence as passed
                let vault_ptr = &raw mut (*fields_ptr).vault;
                ptr::write(
                    vault_ptr,
                    RawProgressorVault {
                        acceptor: SeqAccept {
                            output: InMemoryOutput::new(context),
                            buffer: buffer_ptr,
                        },
                        sequence,
                    },
                );

                // Initialize future: uses sequence + acceptor
                let future_ptr = &raw mut (*fields_ptr).future;
                ptr::write(future_ptr, ManuallyDrop::new(make_fut(&mut *vault_ptr)));

                // Fully initialized!
                NonNull::new_unchecked(fields_ptr as *mut Progressor<Ctx, Seq, Err>)
            }
        }
    }

    impl<Ctx, Seq, Err> Progressor<Ctx, Seq, Err> {
        fn deallocate(ptr: NonNull<Self>) {
            let ptr = ptr.as_ptr();
            unsafe {
                // SAFETY
                // We perform an orderly drop and de-allocation, starting with the future
                {
                    let future_ptr = &raw mut (*ptr).future;
                    let future_ref = (&mut *future_ptr).deref_mut();
                    ptr::drop_in_place(future_ref);
                }
                let _allocation = Box::from_raw(ptr);

                /*
                Ideally, Layout::for_value_raw would be stabilized. Then we remove our use of
                ManuallyDrop and perform manual de-allocation for all the fields, like so:

                // Start with the future, because it holds references to the vault
                ptr::drop_in_place(&raw mut (*ptr).future);

                ptr::drop_in_place(&raw mut (*ptr).buffer);
                ptr::drop_in_place(&raw mut (*ptr).vault);

                // Finally, de-allocate the memory
                let layout = Layout::for_value_raw(ptr);
                std::alloc::dealloc(ptr as *mut u8, layout)
                 */
            }
        }
    }

    impl<Ctx, Seq, Err> Iterator for StringIter<Ctx, Seq, Err> {
        type Item = Result<String, Err>;
        fn next(&mut self) -> Option<Self::Item> {
            if self.finished {
                return None;
            }
            // Check for errors from the previous call
            if let Some(error) = mem::take(&mut self.seq_error_in_pipe) {
                self.finished = true;
                return Some(Err(error));
            }
            let fields_ptr = self.inner.as_ptr();
            let (poll_outcome, item) = unsafe {
                // SAFETY
                // First poll the future
                // We know the future is pinned because it is heap-allocated
                let future_ptr = &raw mut (*fields_ptr).future;
                let pinned_future = Pin::new_unchecked((&mut *future_ptr).deref_mut());

                // Poll the future: can fill the buffer
                let poll_outcome =
                    pinned_future.poll(&mut std::task::Context::from_waker(Waker::noop()));

                // We can now use the buffer freely
                let buffer_ptr = &raw const (*fields_ptr).buffer;
                let item = (&*buffer_ptr).extract();

                (poll_outcome, item)
            };
            match poll_outcome {
                Poll::Pending => {
                    // The future stalling tells us that there is an item in the buffer
                    // So, this should always be Some
                    assert!(
                        item.is_some(),
                        "Extraneous async computations (writable should complete regularly)"
                    );
                }
                Poll::Ready(Err(seq_error)) => {
                    // The sequence itself threw an error
                    // Check whether any Writable was sent to the sequence
                    if item.is_some() {
                        // The sequence produced an item, then returned an error
                        // Store that error and return it in the next round
                        self.seq_error_in_pipe = Some(seq_error);
                    } else {
                        // No item, but everything's done
                        self.finished = true;
                        return Some(Err(seq_error));
                    }
                }
                Poll::Ready(Ok(())) => {
                    // All done!
                    self.finished = true;
                    // item can be None if we are fully empty
                }
            };
            item
        }
    }

    struct SeqAccept<Ctx, Err> {
        output: InMemoryOutput<Ctx, Err>,
        buffer: *const ItemBuffer<Err>,
    }

    impl<Ctx, Err> SequenceAccept<InMemoryOutput<Ctx, Err>> for SeqAccept<Ctx, Err>
    where
        Ctx: Context,
        Err: From<Infallible>,
    {
        async fn accept<W>(&mut self, writable: &W) -> Result<(), Err>
        where
            W: Writable<InMemoryOutput<Ctx, Err>>,
        {
            poll_fn(|_| {
                let buffer = unsafe {
                    // SAFETY
                    // We touch this buffer in one other place, outside the future
                    &*self.buffer
                };
                if !buffer.has_space() {
                    return Poll::Pending;
                }
                let result = self.output.print_output_impl(writable);
                let string = mem::take(&mut self.output.buf);
                buffer.set_new(result.map(|()| string));
                Poll::Ready(Ok(()))
            })
            .await
        }
    }

    struct ItemBuffer<Err> {
        current: UnsafeCell<Option<Result<String, Err>>>,
    }

    impl<Err> Default for ItemBuffer<Err> {
        fn default() -> Self {
            Self {
                current: UnsafeCell::new(None),
            }
        }
    }

    impl<Err> Debug for ItemBuffer<Err>
    where
        Err: Debug,
    {
        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
            unsafe {
                // SAFETY
                // We only read the value and don't modify from anywhere else
                let current = &*self.current.get();
                f.debug_struct("ItemBuffer")
                    .field("current", &current)
                    .finish()
            }
        }
    }

    impl<Err> ItemBuffer<Err> {
        fn has_space(&self) -> bool {
            unsafe {
                // SAFETY
                // We only read and don't modify from anywhere else
                let ptr = self.current.get();
                (&*ptr).is_none()
            }
        }

        fn set_new(&self, value: Result<String, Err>) {
            unsafe {
                // SAFETY
                // We don't modify from anywhere else
                let ptr = self.current.get();
                // Caller assumes responsibility for memory leaks
                ptr::write(ptr, Some(value));
            }
        }

        fn extract(&self) -> Option<Result<String, Err>> {
            unsafe {
                // SAFETY
                // We don't modify from anywhere else
                let ptr = self.current.get();
                mem::replace(&mut *ptr, None)
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::common::{CombinedSeq, NoOpSeq, SingularSeq, Str, StrArrSeq};
    use crate::context::EmptyContext;
    use crate::util::IntoStringIter;
    use crate::{Output, SequenceAccept, Writable, WritableSeq};
    use std::convert::Infallible;

    #[test]
    fn sequence_iterator() {
        let sequence = StrArrSeq(&["One", "Two", "Three"]);
        let iterator = IntoStringIter::new(EmptyContext, sequence);
        let iterator = iterator.into_iter();
        let expected = &["One", "Two", "Three"].map(|s| Ok::<_, Infallible>(String::from(s)));
        assert_eq!(iterator.collect::<Vec<_>>(), Vec::from(expected));
    }

    #[test]
    fn sequence_iterator_empty() {
        let sequence = NoOpSeq;
        let iterator: IntoStringIter<_, _> = IntoStringIter::new(EmptyContext, sequence);
        let iterator = iterator.into_iter();
        assert!(iterator.collect::<Vec<_>>().is_empty());
    }

    #[derive(Clone)]
    struct SequenceWithError<Seq> {
        emit_before: bool,
        seq: Seq,
    }

    #[derive(Clone, Debug, PartialEq, Eq)]
    struct SampleError;

    // Warning: In future rust versions this will be automatically implemented
    impl From<Infallible> for SampleError {
        fn from(value: Infallible) -> Self {
            match value {}
        }
    }

    impl<O, Seq> WritableSeq<O> for SequenceWithError<Seq>
    where
        O: Output<Error = SampleError>,
        Seq: WritableSeq<O>,
    {
        async fn for_each<S>(&self, sink: &mut S) -> Result<(), O::Error>
        where
            S: SequenceAccept<O>,
        {
            if !self.emit_before {
                self.seq.for_each(sink).await?;
            }
            Err(SampleError)
        }
    }

    #[test]
    fn sequence_iterator_seq_error() {
        let sequence = SequenceWithError {
            emit_before: true,
            seq: StrArrSeq(&["Will", "Never", "Be", "Seen"]),
        };
        let iterator = IntoStringIter::<_, _, SampleError>::new(EmptyContext, sequence);
        assert_eq!(Some(Err(SampleError)), iterator.clone().into_iter().next());
        assert!(iterator.into_iter().find(Result::is_ok).is_none());
    }

    #[test]
    fn sequence_iterator_seq_error_afterward() {
        let sequence = SequenceWithError {
            emit_before: false,
            seq: StrArrSeq(&["Data", "More"]),
        };
        let iterator = IntoStringIter::<_, _, SampleError>::new(EmptyContext, sequence);
        assert_eq!(
            vec![
                Ok(String::from("Data")),
                Ok(String::from("More")),
                Err(SampleError)
            ],
            iterator.into_iter().collect::<Vec<_>>()
        );
    }

    #[test]
    fn sequence_iterator_seq_error_in_between() {
        let sequence = CombinedSeq(
            StrArrSeq(&["One", "Two"]),
            SequenceWithError {
                emit_before: true,
                seq: SingularSeq(Str("Final")),
            },
        );
        let iterator = IntoStringIter::<_, _, SampleError>::new(EmptyContext, sequence);
        assert_eq!(
            vec![
                Ok(String::from("One")),
                Ok(String::from("Two")),
                Err(SampleError)
            ],
            iterator.into_iter().collect::<Vec<_>>()
        );
    }

    #[test]
    fn sequence_iterator_seq_error_empty() {
        let sequence = SequenceWithError {
            emit_before: true,
            seq: NoOpSeq,
        };
        let iterator = IntoStringIter::<_, _, SampleError>::new(EmptyContext, sequence);
        assert_eq!(
            vec![Err(SampleError)],
            iterator.into_iter().collect::<Vec<_>>()
        );
    }

    #[derive(Clone, Debug)]
    struct ProduceError;

    impl<O> Writable<O> for ProduceError
    where
        O: Output<Error = SampleError>,
    {
        async fn write_to(&self, _: &mut O) -> Result<(), O::Error> {
            Err(SampleError)
        }
    }

    #[test]
    fn sequence_iterator_write_error() {
        let sequence = CombinedSeq(SingularSeq(ProduceError), StrArrSeq(&["Is", "Seen"]));
        let iterator = IntoStringIter::<_, _, SampleError>::new(EmptyContext, sequence);
        assert_eq!(Some(Err(SampleError)), iterator.clone().into_iter().next());
        assert_eq!(
            vec![
                Err(SampleError),
                Ok(String::from("Is")),
                Ok(String::from("Seen")),
            ],
            iterator.into_iter().collect::<Vec<_>>()
        );
    }

    #[test]
    fn sequence_iterator_write_error_afterward() {
        let sequence = CombinedSeq(StrArrSeq(&["Data", "MoreData"]), SingularSeq(ProduceError));
        let iterator = IntoStringIter::<_, _, SampleError>::new(EmptyContext, sequence);
        assert_eq!(
            vec![
                Ok(String::from("Data")),
                Ok(String::from("MoreData")),
                Err(SampleError)
            ],
            iterator.into_iter().collect::<Vec<_>>()
        );
    }

    #[test]
    fn sequence_iterator_write_error_in_between() {
        let sequence = CombinedSeq(
            StrArrSeq(&["Data", "Adjacent"]),
            CombinedSeq(SingularSeq(ProduceError), SingularSeq(Str("Final"))),
        );
        let iterator = IntoStringIter::<_, _, SampleError>::new(EmptyContext, sequence);
        assert_eq!(
            vec![
                Ok(String::from("Data")),
                Ok(String::from("Adjacent")),
                Err(SampleError),
                Ok(String::from("Final"))
            ],
            iterator.into_iter().collect::<Vec<_>>()
        );
    }
}