Trait Computer 

pub trait Computer<__Context__, Code, Input>: IsProviderFor<ComputerComponent, __Context__, (Code, Input)> {
    type Output;

    // Required method
    fn compute(
        __context__: &__Context__,
        _code: PhantomData<Code>,
        input: Input,
    ) -> Self::Output;
}

Required Associated Types

type Output

Required Methods

fn compute( __context__: &__Context__, _code: PhantomData<Code>, input: Input, ) -> Self::Output

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Context, Code, Input, Tag, Output> Computer<Context, Code, Input> for UseField<Tag>

where Context: HasField<Tag>, Context::Value: CanCompute<Code, Input, Output = Output>,

type Output = Output

fn compute(context: &Context, code: PhantomData<Code>, input: Input) -> Output

impl<__Context__, Code, Input, __Components__, __Delegate__> Computer<__Context__, Code, Input> for UseDelegate<__Components__>

where __Components__: DelegateComponent<Code, Delegate = __Delegate__>, __Delegate__: Computer<__Context__, Code, Input>,

type Output = <__Delegate__ as Computer<__Context__, Code, Input>>::Output

fn compute( __context__: &__Context__, _code: PhantomData<Code>, input: Input, ) -> Self::Output

impl<__Context__, Code, Input> Computer<__Context__, Code, Input> for UseContext

where __Context__: CanCompute<Code, Input>,

type Output = <__Context__ as CanCompute<Code, Input>>::Output

fn compute( __context__: &__Context__, _code: PhantomData<Code>, input: Input, ) -> Self::Output

Implementors

impl<Context, Code, Input, Output, Provider> Computer<Context, Code, Input> for Promote<Provider>

where Provider: Producer<Context, Code, Output = Output>,

type Output = Output

impl<Context, Code, Input, Provider, Output> Computer<Context, Code, Input> for TryPromote<Provider>

where Context: HasErrorType, Provider: TryComputer<Context, Code, Input, Output = Output>,

type Output = Result<Output, <Context as HasErrorType>::Error>

impl<Context, Code, Input, ProviderA, ProviderB> Computer<Context, Code, Input> for ComposeHandlers<ProviderA, ProviderB>

where ProviderA: Computer<Context, Code, Input>, ProviderB: Computer<Context, Code, ProviderA::Output>,

type Output = <ProviderB as Computer<Context, Code, <ProviderA as Computer<Context, Code, Input>>::Output>>::Output

impl<Context, Code, Input, Target, Provider> Computer<Context, Code, Input> for PromoteRef<Provider>

where Provider: ComputerRef<Context, Code, Target>, Input: Deref<Target = Target>,

type Output = <Provider as ComputerRef<Context, Code, Target>>::Output

impl<Context, Code, Input> Computer<Context, Code, Input> for ReturnInput

type Output = Input

impl<__Component__, __Context__, Code, Input> Computer<__Context__, Code, Input> for __Component__

where __Component__: DelegateComponent<ComputerComponent> + IsProviderFor<ComputerComponent, __Context__, (Code, Input)>, __Component__::Delegate: Computer<__Context__, Code, Input>,

type Output = <<__Component__ as DelegateComponent<ComputerComponent>>::Delegate as Computer<__Context__, Code, Input>>::Output

impl<__Context__, Code, Input, __Components__, __Delegate__> Computer<__Context__, Code, Input> for UseInputDelegate<__Components__>

where __Components__: DelegateComponent<Input, Delegate = __Delegate__>, __Delegate__: Computer<__Context__, Code, Input>,

type Output = <__Delegate__ as Computer<__Context__, Code, Input>>::Output