Trait Process

pub trait Process {
    type Item;

    // Provided methods
    fn and_then<U, F>(self, f: F) -> AndThen<Self, U, F>
       where Self: Sized + 'static,
             U: Process + 'static,
             F: FnOnce(Self::Item) -> U + Clone + 'static { ... }
    fn map<B, F>(self, f: F) -> Map<Self, B, F>
       where Self: Sized + 'static,
             F: FnOnce(Self::Item) -> B + Clone + 'static { ... }
    fn zip<U>(self, other: U) -> Zip<Self, U>
       where Self: Sized + 'static,
             Self::Item: Clone,
             U: Process + Clone + 'static { ... }
    fn ap<U, B>(self, other: U) -> Ap<Self, U, B>
       where Self: Sized + 'static,
             Self::Item: FnOnce(U::Item) -> B + Clone,
             U: Process + Clone + 'static,
             B: 'static { ... }
    fn finally<U>(self, finalization: U) -> Finally<Self, U>
       where Self: Sized + 'static,
             Self::Item: Clone,
             U: Process<Item = ()> + Clone + 'static { ... }
    fn run(self) -> Run<Self>
       where Self: Process<Item = ()> + Sized { ... }
    fn run_using_id(self, pid: Grc<ProcessId>) -> Run<Self>
       where Self: Process<Item = ()> + Sized { ... }
    fn into_boxed(self) -> ProcessBox<Self::Item>
       where Self: Sized + Clone + 'static { ... }
}

The computation based on continuations.

Required Associated Types

type Item

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

Provided Methods

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

where Self: Sized + 'static, U: Process + 'static, F: FnOnce(Self::Item) -> U + Clone + '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 + Clone + 'static,

Map the current computation using the specified transform.

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

where Self: Sized + 'static, Self::Item: Clone, U: Process + Clone + '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 + Clone, U: Process + Clone + 'static, B: 'static,

The function application.

fn finally<U>(self, finalization: U) -> Finally<Self, U>

where Self: Sized + 'static, Self::Item: Clone, U: Process<Item = ()> + Clone + '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_id(self, pid: Grc<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 + Clone + 'static,

Convert into a boxed value.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Process for Hold

type Item = ()

impl Process for Id

type Item = Grc<ProcessId>

impl Process for Passivate

type Item = ()

impl Process for ProcessWithPriority

type Item = ()

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

where F: FnOnce() -> M + Clone + 'static, M: Process + 'static,

type Item = <M as Process>::Item

impl<F, M> Process for Loop<F, M>

where F: Fn() -> M + Clone + 'static, M: Process<Item = ()> + 'static,

type Item = <M as Process>::Item

impl<M> Process for EventIntoProcess<M>

where M: Event,

type Item = <M as Event>::Item

impl<M> Process for ParameterIntoProcess<M>

where M: Parameter,

type Item = <M as Parameter>::Item

impl<M> Process for SimulationIntoProcess<M>

where M: Simulation,

type Item = <M as Simulation>::Item

impl<M> Process for PassivateBefore<M>

where M: Event<Item = ()>,

type Item = ()

impl<M> Process for Sequence<M>

where M: Process + Clone + 'static, M::Item: Clone,

type Item = List<<M as Process>::Item>

impl<M> Process for Sequence_<M>

where M: Process + Clone + 'static, M::Item: Clone,

type Item = ()

impl<M> Process for Spawn<M>

where M: Process<Item = ()> + Clone + 'static,

type Item = ()

impl<M> Process for SpawnUsingId<M>

where M: Process<Item = ()> + Clone + 'static,

type Item = ()

impl<M> Process for Timeout<M>

where M: Process + Clone + 'static, M::Item: Clone,

type Item = Option<<M as Process>::Item>

impl<M> Process for TimeoutUsingId<M>

where M: Process + Clone + 'static, M::Item: Clone,

type Item = Option<<M as Process>::Item>

impl<M> Process for Trace<M>

where M: Process,

type Item = <M as Process>::Item

impl<M> Process for WhenCancelling<M>

where M: Observer<Message = (), Item = ()> + Clone + 'static,

type Item = ()

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

where F: FnOnce(M::Item) -> B + Clone + 'static, M: Process + 'static, B: 'static,

type Item = B

impl<M, U> Process for Finally<M, U>

where M: Process + 'static, M::Item: Clone, U: Process<Item = ()> + Clone + 'static,

type Item = <M as Process>::Item

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

where M: Process + 'static, M::Item: Clone, U: Process + Clone + 'static,

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

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

where M: Process + 'static, U: Process + Clone + 'static, M::Item: FnOnce(U::Item) -> B + Clone, B: 'static,

type Item = B

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

where F: FnOnce(M::Item) -> U + Clone + 'static, M: Process + 'static, U: Process + 'static,

type Item = <U as Process>::Item

impl<O, M> Process for Await<O, M>

where O: Observable<Message = M>, M: Clone + 'static,

type Item = M

impl<O, M> Process for AwaitResult<O, M>

where O: Observable<Message = Result<M>>, M: Clone + 'static,

type Item = M

impl<S> Process for dvcompute_branch::simulation::resource::stats::Release<S>

where S: QueueStrategy,

type Item = ()

impl<S> Process for dvcompute_branch::simulation::resource::stats::Request<S>

where S: QueueStrategy + Clone + 'static,

type Item = ()

impl<S> Process for dvcompute_branch::simulation::resource::stats::RequestWithPriority<S>

where S: QueueStrategy + Clone + 'static, S::Priority: Clone,

type Item = ()

impl<S> Process for dvcompute_branch::simulation::resource::Release<S>

where S: QueueStrategy,

type Item = ()

impl<S> Process for dvcompute_branch::simulation::resource::Request<S>

where S: QueueStrategy + Clone + 'static,

type Item = ()

impl<S> Process for dvcompute_branch::simulation::resource::RequestWithPriority<S>

where S: QueueStrategy + Clone + 'static, S::Priority: Clone,

type Item = ()

impl<T> Process for Cancel<T>

type Item = T

impl<T> Process for EmbedResult<T>

type Item = T

impl<T> Process for Never<T>

type Item = T

impl<T> Process for Panic<T>

type Item = T

impl<T> Process for ProcessBox<T>

type Item = T

impl<T> Process for Return<T>

type Item = T

impl<T, M> Process for Transfer<T, M>

where M: Process<Item = ()>,

type Item = T