Trait dvcompute::simulation::process::Process[−][src]

pub trait Process {
    type Item;
    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,
    { ... }

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

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

    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,
    { ... }

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

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

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

    fn into_boxed(self) -> ProcessBox<Self::Item>
    where
        Self: Sized + 'static,
    { ... }
}
Expand description

The computation based on continuations.

Associated Types

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

Provided methods

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

Map the current computation using the specified transform.

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

The function application.

Finalize the current computation regardless of canceling it or not.

Run the Process computation.

Run the Process computation using the specified process identifier.

Convert into a boxed value.

Implementors