Enum gc_sequence::and_then::AndThen

#[must_use = "sequences do nothing unless stepped"]
pub enum AndThen<S, F, I> {
    First(S, Option<StaticCollect<F>>),
    Second(Option<(I, StaticCollect<F>)>),
}

Variants

First(S, Option<StaticCollect<F>>)

Second(Option<(I, StaticCollect<F>)>)

Implementations

impl<S, F, I> AndThen<S, F, I>

pub fn new(s: S, f: F) -> AndThen<S, F, I>

Trait Implementations

impl<S, F, I> Collect for AndThen<S, F, I> where
    S: Collect,
    Option<StaticCollect<F>>: Collect,
    Option<(I, StaticCollect<F>)>: Collect, 

fn needs_trace() -> bool

As an optimization, if this type can never hold a Gc pointer and trace is unnecessary to call, you may implement this method and return false. The default implementation returns true, signaling that Collect::trace must be called.

fn trace(&self, cc: CollectionContext<'_>)

Must call Collect::trace on all held Gc pointers. If this type holds inner types that implement Collect, a valid implementation would simply call Collect::trace on all the held values to ensure this.

impl<S: Debug, F: Debug, I: Debug> Debug for AndThen<S, F, I>

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

Formats the value using the given formatter.

impl<S, F, I> MustNotImplDrop for AndThen<S, F, I>

impl<'gc, S, F, I, E, R> Sequence<'gc> for AndThen<S, F, I> where
    S: Sequence<'gc, Output = Result<I, E>>,
    I: Collect,
    F: 'static + FnOnce(MutationContext<'gc, '_>, I) -> Result<R, E>, 

type Output = Result<R, E>

fn step(&mut self, mc: MutationContext<'gc, '_>) -> Option<Self::Output>