Trait dvcompute::simulation::composite::Composite[−][src]

pub trait Composite {
    type Item;
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
        Self: Sized,
        U: Composite,
        F: FnOnce(Self::Item) -> U,
    { ... }

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

    fn zip<U>(self, other: U) -> Zip<Self, U>
    where
        Self: Sized,
        U: Composite,
    { ... }

    fn ap<U, B>(self, other: U) -> Ap<Self, U, B>
    where
        Self: Sized,
        Self::Item: FnOnce(U::Item) -> B,
        U: Composite,
    { ... }

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

    fn run<D>(self, disposable: D) -> Run<Self, D>
    where
        Self: Sized,
        D: Disposable + 'static,
    { ... }

    fn run_(self) -> Run_<Self>
    where
        Self: Sized,
    { ... }
}
Expand description

The computation synchronized with the composite queue.

Associated Types

The type of the item that is returned in the current modeling time.

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.

Convert into a boxed value.

Run the computation by the specified initial Disposable object.

[src]

fn run_(self) -> Run_<Self> where
    Self: Sized, 

Run the computation by ignoring Disposable objects.

Implementors