Struct Coroutine 

pub struct Coroutine { /* private fields */ }

Two cooperating value streams that yield by alternating between lanes.

Models symmetric coroutine control: each Coroutine::resume hands control to the next lane, falling through to the other when one is drained.

Examples

use sim_kernel::{Ref, Symbol};
use sim_lib_control::{Coroutine, CoroutineLane, CoroutineStep};

let a = Ref::Symbol(Symbol::new("a"));
let b = Ref::Symbol(Symbol::new("b"));
let mut co = Coroutine::alternating(vec![a.clone()], vec![b.clone()]);
assert_eq!(
    co.resume(),
    CoroutineStep::Yielded { lane: CoroutineLane::First, value: a }
);
assert_eq!(
    co.resume(),
    CoroutineStep::Yielded { lane: CoroutineLane::Second, value: b }
);
assert_eq!(co.resume(), CoroutineStep::Exhausted);

Implementations

impl Coroutine

pub fn alternating(first: Vec<Ref>, second: Vec<Ref>) -> Self

Builds a coroutine that alternates yields between the first and second lanes, starting with the first.

pub fn resume(&mut self) -> CoroutineStep

Resumes the coroutine, yielding the next value from the active lane (or the other lane if the active one is drained), or CoroutineStep::Exhausted when both are empty.

Trait Implementations

impl Clone for Coroutine

fn clone(&self) -> Coroutine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Coroutine

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

Formats the value using the given formatter.

impl Eq for Coroutine

impl PartialEq for Coroutine

fn eq(&self, other: &Coroutine) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Coroutine