Enum gc_sequence::flatten::Flatten

#[must_use = "sequences do nothing unless stepped"]
pub enum Flatten<'gc, S> where
    S: Sequence<'gc>,
    S::Output: Sequence<'gc>,  {
    First(S),
    Second(S::Output),
}

Variants

First(S)Second(S::Output)

Methods

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

pub fn new(s: S) -> Flatten<'gc, S>

Trait Implementations

impl<'gc, S> Sequence<'gc> for Flatten<'gc, S> where
    S: Sequence<'gc>,
    S::Output: Sequence<'gc>, 

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

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

impl<'gc, S> Drop for Flatten<'gc, S> where
    S: Sequence<'gc>,
    S::Output: Sequence<'gc>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<'gc, S> Collect for Flatten<'gc, S> where
    S: Sequence<'gc>,
    S::Output: Sequence<'gc>,
    S: Collect,
    S::Output: 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.