Struct dvcompute::simulation::process::Sequence

pub struct Sequence<I, M> where
    M: Process,  { /* fields omitted */ }

The sequence of computations.

Trait Implementations

impl<I: Clone, M: Clone> Clone for Sequence<I, M> where
    M: Process,
    M::Item: Clone, 

fn clone(&self) -> Sequence<I, M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, M> Process for Sequence<I, M> where
    I: Iterator<Item = M> + 'static,
    M: Process + 'static, 

type Item = Vec<M::Item>

The type of the item that is used within the computation.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    Self: Sized + 'static,
    U: Process + 'static,
    F: FnOnce(Self::Item) -> U + 'static, 

Bind the current computation with its continuation within the resulting computation.

fn map<B, F>(self, f: F) -> Map<Self, B, F> where
    Self: Sized + 'static,
    F: FnOnce(Self::Item) -> B + 'static, 

Map the current computation using the specified transform.

fn zip<U>(self, other: U) -> Zip<Self, U> where
    Self: Sized + 'static,
    U: Process + 'static, 

Zip the current computation with another one within the resulting computation.

fn ap<U, B>(self, other: U) -> Ap<Self, U, B> where
    Self: Sized + 'static,
    Self::Item: FnOnce(U::Item) -> B,
    U: Process + 'static,
    B: 'static, 

The function application.

fn finally<U>(self, finalization: U) -> Finally<Self, U> where
    Self: Sized + 'static,
    U: Process<Item = ()> + 'static, 

Finalize the current computation regardless of canceling it or not.

fn run(self) -> Run<Self> where
    Self: Process<Item = ()> + Sized, 

Run the Process computation.

fn run_using_pid(self, pid: Rc<ProcessId>) -> Run<Self> where
    Self: Process<Item = ()> + Sized, 

Run the Process computation using the specified process identifier.

fn into_boxed(self) -> ProcessBox<Self::Item> where
    Self: Sized + 'static, 

Convert into a boxed value.