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", so this trait is not object safe.

Implementors

impl<'a, Context, Code, Input, Args, Output, Remainder, Handlers> Computer<Context, Code, (&'a Input, Args)> for MatchFirstWithHandlersRef<Handlers>

where Input: HasExtractorRef, PipeMonadic<OkMonadic, Handlers>: Computer<Context, Code, (<Input as HasExtractorRef>::ExtractorRef<'a>, Args), Output = Result<Output, (Remainder, Args)>>, Remainder: FinalizeExtract,

type Output = Output

impl<'a, Context, Code, Input, Args, Output, Remainder, Handlers> Computer<Context, Code, (&'a mut Input, Args)> for MatchFirstWithHandlersMut<Handlers>

where Input: HasExtractorMut, PipeMonadic<OkMonadic, Handlers>: Computer<Context, Code, (<Input as HasExtractorMut>::ExtractorMut<'a>, Args), Output = Result<Output, (Remainder, Args)>>, Remainder: FinalizeExtract,

type Output = Output

impl<'a, Context, Code, Input, Output, Remainder, Handlers> Computer<Context, Code, &'a Input> for MatchWithHandlersRef<Handlers>

where Input: HasExtractorRef, PipeMonadic<OkMonadic, Handlers>: Computer<Context, Code, <Input as HasExtractorRef>::ExtractorRef<'a>, Output = Result<Output, Remainder>>, Remainder: FinalizeExtract,

type Output = Output

impl<'a, Context, Code, Input, Output, Remainder, Handlers> Computer<Context, Code, &'a mut Input> for MatchWithHandlersMut<Handlers>

where Input: HasExtractorMut, PipeMonadic<OkMonadic, Handlers>: Computer<Context, Code, <Input as HasExtractorMut>::ExtractorMut<'a>, Output = Result<Output, Remainder>>, Remainder: FinalizeExtract,

type Output = Output

impl<Context, Code, Builder, Provider, Output, Res> Computer<Context, Code, Builder> for BuildAndMerge<Provider>

where Provider: for<'a> Computer<Context, Code, &'a Builder, Output = Res>, Builder: CanBuildFrom<Res, Output = Output>,

type Output = Output

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

type Output = Input

impl<Context, Code, Input, Args, Output, Remainder, Handlers> Computer<Context, Code, (Input, Args)> for MatchFirstWithHandlers<Handlers>

where Input: HasExtractor, PipeMonadic<OkMonadic, Handlers>: Computer<Context, Code, (<Input as HasExtractor>::Extractor, Args), Output = Result<Output, (Remainder, Args)>>, Remainder: FinalizeExtract,

type Output = Output

impl<Context, Code, Input, Args, Tag, Value, Provider, Output, Remainder> Computer<Context, Code, (Input, Args)> for ExtractFirstFieldAndHandle<Tag, Provider>

where Input: ExtractField<Tag, Value = Value, Remainder = Remainder>, Provider: Computer<Context, Code, (ω<Tag, Value>, Args), Output = Output>,

type Output = Result<Output, (Remainder, Args)>

impl<Context, Code, Input, Output, Builder, Handlers, Res> Computer<Context, Code, Input> for BuildWithHandlers<Output, Handlers>

where Output: HasBuilder<Builder = Builder>, PipeHandlers<Handlers>: Computer<Context, Code, Builder, Output = Res>, Res: FinalizeBuild<Target = Output>,

type Output = Output

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, Output, Remainder, Handlers> Computer<Context, Code, Input> for MatchWithHandlers<Handlers>

where Input: HasExtractor, PipeMonadic<OkMonadic, Handlers>: Computer<Context, Code, <Input as HasExtractor>::Extractor, Output = Result<Output, Remainder>>, Remainder: FinalizeExtract,

type Output = Output

impl<Context, Code, Input, Provider, Inner, Output, Remainder> Computer<Context, Code, Input> for DowncastAndHandle<Inner, Provider>

where Input: CanDowncastFields<Inner, Remainder = Remainder>, Provider: Computer<Context, Code, Inner, Output = Output>,

type Output = Result<Output, Remainder>

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 as Computer<Context, Code, Input>>::Output>,

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

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

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

type Output = Output

impl<Context, Code, Input, Tag, Value, Provider, Output, Remainder> Computer<Context, Code, Input> for ExtractFieldAndHandle<Tag, Provider>

where Input: ExtractField<Tag, Value = Value, Remainder = Remainder>, Provider: Computer<Context, Code, ω<Tag, Value>, Output = Output>,

type Output = Result<Output, Remainder>

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, T1, T2, E, M, Cont> Computer<Context, Code, Result<T1, E>> for BindErr<M, Cont>

where Cont: Computer<Context, Code, T1>, M: ContainsValue<<Cont as Computer<Context, Code, T1>>::Output, Value = Result<T2, E>> + LiftValue<Result<T2, E>, <Cont as Computer<Context, Code, T1>>::Output>,

type Output = <M as LiftValue<Result<T2, E>, <Cont as Computer<Context, Code, T1>>::Output>>::Output

impl<Context, Code, T, E1, E2, M, Cont> Computer<Context, Code, Result<T, E1>> for BindOk<M, Cont>

where Cont: Computer<Context, Code, E1>, M: ContainsValue<<Cont as Computer<Context, Code, E1>>::Output, Value = Result<T, E2>> + LiftValue<Result<T, E2>, <Cont as Computer<Context, Code, E1>>::Output>,

type Output = <M as LiftValue<Result<T, E2>, <Cont as Computer<Context, Code, E1>>::Output>>::Output

impl<Context, Code, Tag, Input, Args, Output, Provider> Computer<Context, Code, (ω<Tag, Input>, Args)> for HandleFirstFieldValue<Provider>

where Provider: Computer<Context, Code, (Input, Args), Output = Output>,

type Output = Output

impl<Context, Code, Tag, Input, Output, Provider> Computer<Context, Code, ω<Tag, Input>> for HandleFieldValue<Provider>

where Provider: Computer<Context, Code, Input, Output = Output>,

type Output = Output

impl<Context, Code, Tag, Value, Provider, Output, Builder> Computer<Context, Code, Builder> for BuildAndSetField<Tag, Provider>

where Provider: for<'a> Computer<Context, Code, &'a Builder, Output = Value>, Builder: BuildField<Tag, Value = Value, Output = Output>,

type Output = Output

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

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

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

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

where __Context__: CanCompute<Code, Input>,

type Output = <__Context__ as CanCompute<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

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