Trait dvcompute::simulation::simulation::Simulation[−][src]

pub trait Simulation {
    type Item;
    fn into_event(self) -> SimulationIntoEvent<Self>
    where
        Self: Sized,
    { ... }

    fn into_process(self) -> SimulationIntoProcess<Self>
    where
        Self: Sized,
    { ... }

    fn into_composite(self) -> SimulationIntoComposite<Self>
    where
        Self: Sized,
    { ... }

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
        Self: Sized,
        U: Simulation,
        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: Simulation,
    { ... }

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

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

    fn run(self, specs: Specs) -> Result<Self::Item>
    where
        Self: Sized,
    { ... }

    fn run_by_index(
        self, 
        specs: Specs, 
        run_index: usize, 
        run_count: usize
    ) -> Result<Self::Item>
    where
        Self: Sized,
    { ... }

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

The computation of arbitrary function of simulation run.

Associated Types

The type of the item that is returned in within the simulation run.

Provided methods

Convert into the Event computation.

Convert to the Process computation.

Convert into the Composite computation.

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 simulation.

Run the simulation by index.

Convert into a boxed value.

Implementors