Trait Service 

pub trait Service<Req = ()> {
    type Response;
    type Error;

    // Required method
    fn call(
        &self,
        req: Req,
    ) -> impl Future<Output = Result<Self::Response, Self::Error>>;
}

Trait for simulate Fn<(&Self, Arg)> -> impl Future<Output = Result<T, E>> + '_. The function call come from stateful type that can be referenced within returned opaque future.

Required Associated Types

type Response

The Ok part of output future.

type Error

The Err part of output future.

Required Methods

fn call( &self, req: Req, ) -> impl Future<Output = Result<Self::Response, Self::Error>>

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.

Implementations on Foreign Types

impl<S, Req> Service<Req> for Pin<S>

where S: Deref, S::Target: Service<Req>,

type Response = <<S as Deref>::Target as Service<Req>>::Response

type Error = <<S as Deref>::Target as Service<Req>>::Error

async fn call(&self, req: Req) -> Result<Self::Response, Self::Error>

impl<T, S, E> Service<Result<S, E>> for Option<T>

where T: Service<Result<S, E>, Error = E>,

type Response = Pipeline<S, <T as Service<Result<S, E>>>::Response>

type Error = <T as Service<Result<S, E>>>::Error

async fn call(&self, res: Result<S, E>) -> Result<Self::Response, Self::Error>

Implementors

impl<F, Req, Res, Err> Service<Req> for FnService<F>

where F: AsyncFn(Req) -> Result<Res, Err>,

type Response = Res

type Error = Err

impl<F, S, Req> Service<Req> for Pipeline<F, S>

where F: Service<Req>, S: Service<Req, Response = F::Response, Error = F::Error>,

type Response = <F as Service<Req>>::Response

type Error = <F as Service<Req>>::Error

impl<F, T, Arg> Service<Arg> for PipelineT<F, T, BuildEnclosed>

where F: Service<Arg>, T: Service<Result<F::Response, F::Error>>,

type Response = <T as Service<Result<<F as Service<Arg>>::Response, <F as Service<Arg>>::Error>>>::Response

type Error = <T as Service<Result<<F as Service<Arg>>::Response, <F as Service<Arg>>::Error>>>::Error

impl<S, E> Service<Result<S, E>> for Group<S, E>

type Response = S

type Error = E

impl<S, E> Service<Result<S, E>> for UncheckedReady

type Response = UncheckedReadyService<S>

type Error = E

impl<S, E, F> Service<Result<S, E>> for AsyncFn<F>

where F: Clone,

type Response = Pipeline<S, F, AsyncFn>

type Error = E

impl<S, Req, F, Err> Service<Req> for PipelineT<S, F, MapErr>

where S: Service<Req>, F: Fn(S::Error) -> Err,

type Response = <S as Service<Req>>::Response

type Error = Err

impl<S, Req, F, Res> Service<Req> for PipelineT<S, F, Map>

where S: Service<Req>, F: Fn(S::Response) -> Res,

type Response = Res

type Error = <S as Service<Req>>::Error

impl<S, Req, F, Res, Err> Service<Req> for PipelineT<S, F, AsyncFn>

where F: AsyncFn(&S, Req) -> Result<Res, Err>,

type Response = Res

type Error = Err

impl<S, Req, S1> Service<Req> for PipelineT<S, S1, AndThen>

where S: Service<Req>, S1: Service<S::Response, Error = S::Error>,

type Response = <S1 as Service<<S as Service<Req>>::Response>>::Response

type Error = <S as Service<Req>>::Error

impl<SF, Arg, SF1> Service<Arg> for PipelineT<SF, SF1, BuildAndThen>

where SF: Service<Arg>, Arg: Clone, SF1: Service<Arg>, SF1::Error: From<SF::Error>,

type Response = Pipeline<<SF as Service<Arg>>::Response, <SF1 as Service<Arg>>::Response, AndThen>

type Error = <SF1 as Service<Arg>>::Error