Trait Sequence 

pub trait Sequence<'gc>: Collect {
    type Output;

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

A trait that describes a sequence of actions to perform, in between which garbage collection may take place.

This trait is similar to the Future trait in that it is not designed to be used directly, but rather chained together using combinators and run to completion with a sequencer.

Required Associated Types

type Output

Required Methods

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

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'gc, T: ?Sized + Sequence<'gc>> Sequence<'gc> for Box<T>

type Output = <T as Sequence<'gc>>::Output

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

Implementors

impl<'gc, C, F, R> Sequence<'gc> for SequenceFnWith<C, F>

where F: 'static + FnOnce(MutationContext<'gc, '_>, C) -> R, C: Collect,

type Output = R

impl<'gc, F, R> Sequence<'gc> for SequenceFn<F>

where F: 'static + FnOnce(MutationContext<'gc, '_>) -> R,

type Output = R

impl<'gc, O: Collect> Sequence<'gc> for Done<O>

type Output = O

impl<'gc, S, C, F, I, E, R> Sequence<'gc> for AndThenWith<S, C, F, I>

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

type Output = Result<R, E>

impl<'gc, S, C, F, I, E, R> Sequence<'gc> for MapOkWith<S, C, F>

where S: Sequence<'gc, Output = Result<I, E>>, C: Collect, F: 'static + FnOnce(C, I) -> R,

type Output = Result<R, E>

impl<'gc, S, C, F, R> Sequence<'gc> for MapWith<S, C, F>

where S: Sequence<'gc>, C: Collect, F: 'static + FnOnce(C, S::Output) -> R,

type Output = R

impl<'gc, S, C, F, R> Sequence<'gc> for ThenWith<'gc, S, C, F>

where S: Sequence<'gc>, S::Output: Collect, C: Collect, F: 'static + FnOnce(MutationContext<'gc, '_>, C, S::Output) -> R,

type Output = R

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>

impl<'gc, S, F, I, E, R> Sequence<'gc> for MapError<S, F>

where S: Sequence<'gc, Output = Result<I, E>>, F: 'static + FnOnce(E) -> R,

type Output = Result<I, R>

impl<'gc, S, F, I, E, R> Sequence<'gc> for MapOk<S, F>

where S: Sequence<'gc, Output = Result<I, E>>, F: 'static + FnOnce(I) -> R,

type Output = Result<R, E>

impl<'gc, S, F, R> Sequence<'gc> for Map<S, F>

where S: Sequence<'gc>, F: 'static + FnOnce(S::Output) -> R,

type Output = R

impl<'gc, S, F, R> Sequence<'gc> for Then<'gc, S, F>

where S: Sequence<'gc>, S::Output: Collect, F: 'static + FnOnce(MutationContext<'gc, '_>, S::Output) -> R,

type Output = R

impl<'gc, S, I, E, I2> Sequence<'gc> for FlattenOk<S, I>

where S: Sequence<'gc, Output = Result<I, E>>, I: Sequence<'gc, Output = Result<I2, E>>,

type Output = Result<I2, E>

impl<'gc, S> Sequence<'gc> for Flatten<'gc, S>

where S: Sequence<'gc>, S::Output: Sequence<'gc>,

type Output = <<S as Sequence<'gc>>::Output as Sequence<'gc>>::Output