Trait Composite

pub trait Composite {
    type Item;

    // Provided methods
    fn and_then<U, F>(self, f: F) -> AndThen<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 + Clone + 'static { ... }
    fn run<D>(self, disposable: D) -> Run<Self, D>
       where Self: Sized,
             D: Disposable + Clone + 'static { ... }
    fn run_(self) -> Run_<Self>
       where Self: Sized { ... }
}

The computation synchronized with the composite queue.

Required Associated Types

type Item

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

Provided Methods

fn and_then<U, F>(self, f: F) -> AndThen<Self, U, F>

where Self: Sized, U: Composite, F: FnOnce(Self::Item) -> U,

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, F: FnOnce(Self::Item) -> B,

Map the current computation using the specified transform.

fn zip<U>(self, other: U) -> Zip<Self, U>

where Self: Sized, U: Composite,

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, Self::Item: FnOnce(U::Item) -> B, U: Composite,

The function application.

fn into_boxed(self) -> CompositeBox<Self::Item>

where Self: Sized + Clone + 'static,

Convert into a boxed value.

fn run<D>(self, disposable: D) -> Run<Self, D>

where Self: Sized, D: Disposable + Clone + 'static,

Run the computation by the specified initial Disposable object.

fn run_(self) -> Run_<Self>

where Self: Sized,

Run the computation by ignoring Disposable objects.

Implementors

impl<D> Composite for DisposableComposite<D>

where D: Disposable + Clone + 'static,

type Item = ()

impl<F, M> Composite for Delay<F, M>

where F: FnOnce() -> M, M: Composite,

type Item = <M as Composite>::Item

impl<F, T> Composite for Cons<F, T>

where F: FnOnce(DisposableBox, &Point<'_>) -> Result<(T, DisposableBox)>,

type Item = T

impl<I, M> Composite for Sequence<I, M>

where I: Iterator<Item = M>, M: Composite,

type Item = Vec<<M as Composite>::Item>

impl<I, M> Composite for Sequence_<I, M>

where I: Iterator<Item = M>, M: Composite,

type Item = ()

impl<M> Composite for EventIntoComposite<M>

where M: Event,

type Item = <M as Event>::Item

impl<M> Composite for ParameterIntoComposite<M>

where M: Parameter,

type Item = <M as Parameter>::Item

impl<M> Composite for SimulationIntoComposite<M>

where M: Simulation,

type Item = <M as Simulation>::Item

impl<M> Composite for Trace<M>

where M: Composite,

type Item = <M as Composite>::Item

impl<M, B, F> Composite for Map<M, B, F>

where M: Composite, F: FnOnce(M::Item) -> B,

type Item = B

impl<M, U> Composite for Zip<M, U>

where M: Composite, U: Composite,

type Item = (<M as Composite>::Item, <U as Composite>::Item)

impl<M, U, B> Composite for Ap<M, U, B>

where M: Composite, U: Composite, M::Item: FnOnce(U::Item) -> B,

type Item = B

impl<M, U, F> Composite for AndThen<M, U, F>

where M: Composite, U: Composite, F: FnOnce(M::Item) -> U,

type Item = <U as Composite>::Item

impl<T> Composite for CompositeBox<T>

type Item = T

impl<T> Composite for Return<T>

type Item = T