Enum tower::util::Either[−][src]

pub enum Either<A, B> {
    A(A),
    B(B),
}

Expand description

Combine two different service types into a single type.

Both services must be of the same request, response, and error types. Either is useful for handling conditional branching in service middleware to different inner service types.

Variants

A(A)

One type of backing Service.

Tuple Fields of A

0: A

B(B)

The other type of backing Service.

Tuple Fields of B

0: B

Trait Implementations

[src]

impl<A: Clone, B: Clone> Clone for Either<A, B>

[src]

fn clone(&self) -> Either<A, B>ⓘ
Notable traits for Either<A, B>
`impl<A, B, T, AE, BE> Future for Either<A, B> where A: Future<Output = Result<T, AE>>, AE: Into<BoxError>, B: Future<Output = Result<T, BE>>, BE: Into<BoxError>, type Output = Result<T, BoxError>;`

Returns a copy of the value. Read more

1.0.0[src]

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

[src]

impl<A: Debug, B: Debug> Debug for Either<A, B>

[src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

[src]

impl<A, B, T, AE, BE> Future for Either<A, B> where
 A: Future<Output = Result<T, AE>>,
 AE: Into<BoxError>,
 B: Future<Output = Result<T, BE>>,
 BE: Into<BoxError>,

type Output = Result<T, BoxError>

The type of value produced on completion.

[src]

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

[src]

impl<S, A, B> Layer<S> for Either<A, B> where
A: Layer<S>,
B: Layer<S>,

type Service = Either<A::Service, B::Service>

The wrapped service

[src]

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware. Read more

[src]

impl<A, B, Request> Service<Request> for Either<A, B> where
 A: Service<Request>,
 A::Error: Into<BoxError>,
 B: Service<Request, Response = A::Response>,
 B::Error: Into<BoxError>,

type Response = A::Response

Responses given by the service.

type Error = BoxError

Errors produced by the service.

type Future = Either<A::Future, B::Future>

The future response value.

[src]

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

[src]

fn call(&mut self, request: Request) -> Self::Future

Process the request and return the response asynchronously. Read more

[src]

impl<'pin, A, B> Unpin for Either<A, B> where
__Either<'pin, A, B>: Unpin,

Auto Trait Implementations

impl<A, B> RefUnwindSafe for Either<A, B> where
A: RefUnwindSafe,
B: RefUnwindSafe,

impl<A, B> Send for Either<A, B> where
A: Send,
B: Send,

impl<A, B> Sync for Either<A, B> where
A: Sync,
B: Sync,

impl<A, B> UnwindSafe for Either<A, B> where
A: UnwindSafe,
B: UnwindSafe,

Blanket Implementations

[src]

impl<T> Any for T where
T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

[src]

impl<T> Borrow<T> for T where
T: ?Sized,

[src]

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

[src]

impl<T> BorrowMut<T> for T where
T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

[src]

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

Performs the conversion.

[src]

impl<T> FutureExt for T where
T: Future + ?Sized,

[src]

fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U,

Map this future’s output to a different type, returning a new future of the resulting type. Read more

[src]

fn map_into(self) -> MapInto<Self, U> where
Self::Output: Into,

Map this future’s output to a different type, returning a new future of the resulting type. Read more

[src]

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,

Chain on a computation for when a future finished, passing the result of the future to the provided closure f. Read more

[src]

fn left_future(self) -> Either<Self, B> where
B: Future<Output = Self::Output>,

Wrap this future in an Either future, making it the left-hand variant of that Either. Read more

[src]

fn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>,

Wrap this future in an Either future, making it the right-hand variant of that Either. Read more

[src]

fn into_stream(self) -> IntoStream<Self>

Convert this future into a single element stream. Read more

[src]

fn flatten(self) -> Flatten<Self> where
Self::Output: Future,

Flatten the execution of this future when the output of this future is itself another future. Read more

[src]

fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,

Flatten the execution of this future when the successful result of this future is a stream. Read more

[src]

fn fuse(self) -> Fuse<Self>

Fuse a future such that poll will never again be called once it has completed. This method can be used to turn any Future into a FusedFuture. Read more

[src]

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output),

Do something with the output of a future before passing it on. Read more

[src]

fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,

Catches unwinding panics while polling the future. Read more

[src]

fn shared(self) -> Shared<Self> where
Self::Output: Clone,

Create a cloneable handle to this future where all handles will resolve to the same result. Read more

[src]

fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>> where
Self: 'a + Send,

Wrap the future in a Box, pinning it. Read more

[src]

fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where
Self: 'a,

Wrap the future in a Box, pinning it. Read more

[src]

fn unit_error(self) -> UnitError<Self>

Turns a Future<Output = T> into a TryFuture<Ok = T, Error = ()>. Read more

[src]

fn never_error(self) -> NeverError<Self>

Turns a Future<Output = T> into a TryFuture<Ok = T, Error = Never>. Read more

[src]

fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,

A convenience for calling Future::poll on Unpin future types.

[src]

fn now_or_never(self) -> Option<Self::Output>

Evaluates and consumes the future, returning the resulting output if the future is ready after the first call to Future::poll. Read more

[src]

impl<T> Instrument for T

[src]

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

[src]

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

[src]

impl<T, U> Into for T where
U: From<T>,

[src]

pub fn into(self) -> U

Performs the conversion.

[src]

impl<F> IntoFuture for F where
F: Future,

type Output = <F as Future>::Output

🔬 This is a nightly-only experimental API. (into_future)

The output that the future will produce on completion.

type Future = F

🔬 This is a nightly-only experimental API. (into_future)

Which kind of future are we turning this into?

[src]

pub fn into_future(self) -> <F as IntoFuture>::Future

🔬 This is a nightly-only experimental API. (into_future)

Creates a future from a value.

[src]

impl<T, Request> ServiceExt<Request> for T where
T: Service<Request> + ?Sized,

[src]

fn ready(&mut self) -> Ready<'_, Self, Request>ⓘ
Notable traits for Ready<'a, T, Request>
`impl<'a, T, Request> Future for Ready<'a, T, Request> where T: Service<Request>, type Output = Result<&'a mut T, T::Error>;`
where
Self: Sized,

Yields a mutable reference to the service when it is ready to accept a request.

[src]

fn ready_and(&mut self) -> ReadyAnd<'_, Self, Request> where
Self: Sized,

👎 Deprecated since 0.4.6:

please use the ServiceExt::ready method instead

Yields a mutable reference to the service when it is ready to accept a request.

[src]

fn ready_oneshot(self) -> ReadyOneshot<Self, Request>ⓘ
Notable traits for ReadyOneshot<T, Request>
`impl<T, Request> Future for ReadyOneshot<T, Request> where T: Service<Request>, type Output = Result<T, T::Error>;`
where
Self: Sized,

Yields the service when it is ready to accept a request.

[src]

fn oneshot(self, req: Request) -> Oneshot<Self, Request>ⓘ
Notable traits for Oneshot<S, Req>
`impl<S, Req> Future for Oneshot<S, Req> where S: Service<Req>, type Output = Result<S::Response, S::Error>;`
where
Self: Sized,

Consume this Service, calling with the providing request once it is ready.

[src]

fn call_all<S>(self, reqs: S) -> CallAll<Self, S> where
 Self: Sized,
 Self::Error: Into<BoxError>,
 S: Stream<Item = Request>,

Process all requests from the given Stream, and produce a Stream of their responses. Read more

[src]

fn and_then<F>(self, f: F) -> AndThen<Self, F> where
Self: Sized,
F: Clone,

Executes a new future after this service’s future resolves. This does not alter the behaviour of the poll_ready method. Read more

[src]

fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F> where
Self: Sized,
F: FnOnce(Self::Response) -> Response + Clone,

Maps this service’s response value to a different value. This does not alter the behaviour of the poll_ready method. Read more

[src]

fn map_err<F, Error>(self, f: F) -> MapErr<Self, F> where
Self: Sized,
F: FnOnce(Self::Error) -> Error + Clone,

Maps this service’s error value to a different value. This does not alter the behaviour of the poll_ready method. Read more

[src]

fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F> where
 Self: Sized,
 Error: From<Self::Error>,
 F: FnOnce(Result<Self::Response, Self::Error>) -> Result<Response, Error> + Clone,

Maps this service’s result type (Result<Self::Response, Self::Error>) to a different value, regardless of whether the future succeeds or fails. Read more

[src]

fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F> where
Self: Sized,
F: FnMut(NewRequest) -> Request + Clone,

Composes a function in front of the service. Read more

[src]

fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F> where
 Self: Sized,
 Error: From<Self::Error>,
 F: FnOnce(Result<Self::Response, Self::Error>) -> Fut + Clone,
 Fut: Future<Output = Result<Response, Error>>,

Composes an asynchronous function after this service. Read more

[src]

fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F> where
 Self: Sized,
 F: FnMut(Self::Future) -> Fut,
 Error: From<Self::Error>,
 Fut: Future<Output = Result<Response, Error>>,

Composes a function that transforms futures produced by the service. Read more

[src]

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

[src]

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

[src]

pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

[src]

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

[src]

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

[src]

impl<F, T, E> TryFuture for F where
F: Future<Output = Result<T, E>> + ?Sized,

type Ok = T

The type of successful values yielded by this future

type Error = E

The type of failures yielded by this future

[src]

pub fn try_poll(
self: Pin<&mut F>,
cx: &mut Context<'_>
) -> Poll<<F as Future>::Output>

Poll this TryFuture as if it were a Future. Read more

[src]

impl<Fut> TryFutureExt for Fut where
Fut: TryFuture + ?Sized,

[src]

fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnOnce(Self::Ok) -> T,

Maps this future’s success value to a different value. Read more

[src]

fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E> where
F: FnOnce(Self::Ok) -> T,
E: FnOnce(Self::Error) -> T,

Maps this future’s success value to a different value, and permits for error handling resulting in the same type. Read more

[src]

fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnOnce(Self::Error) -> E,

Maps this future’s error value to a different value. Read more

[src]

fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,

Maps this future’s Error to a new error type using the Into trait. Read more

[src]

fn ok_into(self) -> OkInto<Self, U> where
Self::Ok: Into,

Maps this future’s Ok to a new type using the Into trait. Read more

[src]

fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,

Executes another future after this one resolves successfully. The success value is passed to a closure to create this subsequent future. Read more

[src]

fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,

Executes another future if this one resolves to an error. The error value is passed to a closure to create this subsequent future. Read more

[src]

fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnOnce(&Self::Ok),

Do something with the success value of a future before passing it on. Read more

[src]

fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnOnce(&Self::Error),

Do something with the error value of a future before passing it on. Read more

[src]

fn try_flatten(self) -> TryFlatten<Self, Self::Ok> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,

Flatten the execution of this future when the successful result of this future is another future. Read more

[src]

fn try_flatten_stream(self) -> TryFlattenStream<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error,

Flatten the execution of this future when the successful result of this future is a stream. Read more

[src]

fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> where
F: FnOnce(Self::Error) -> Self::Ok,

Unwraps this future’s output, producing a future with this future’s Ok type as its Output type. Read more

[src]

fn into_future(self) -> IntoFuture<Self>

Wraps a TryFuture into a type that implements Future. Read more

[src]

fn try_poll_unpin(
 &mut self,
 cx: &mut Context<'_>
) -> Poll<Result<Self::Ok, Self::Error>> where
 Self: Unpin,

A convenience method for calling TryFuture::try_poll on Unpin future types. Read more

[src]

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

[src]

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

[src]

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Enum tower::util::Either[−][src]

Variants

Tuple Fields of A

Tuple Fields of B

Trait Implementations

impl<A: Clone, B: Clone> Clone for Either<A, B>

fn clone(&self) -> Either<A, B>ⓘNotable traits for Either<A, B>impl<A, B, T, AE, BE> Future for Either<A, B> where A: Future<Output = Result<T, AE>>, AE: Into<BoxError>, B: Future<Output = Result<T, BE>>, BE: Into<BoxError>, type Output = Result<T, BoxError>;

fn clone_from(&mut self, source: &Self)

impl<A: Debug, B: Debug> Debug for Either<A, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<A, B, T, AE, BE> Future for Either<A, B> where A: Future<Output = Result<T, AE>>, AE: Into<BoxError>, B: Future<Output = Result<T, BE>>, BE: Into<BoxError>,

type Output = Result<T, BoxError>

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

impl<S, A, B> Layer<S> for Either<A, B> where A: Layer<S>, B: Layer<S>,

type Service = Either<A::Service, B::Service>

fn layer(&self, inner: S) -> Self::Service

impl<A, B, Request> Service<Request> for Either<A, B> where A: Service<Request>, A::Error: Into<BoxError>, B: Service<Request, Response = A::Response>, B::Error: Into<BoxError>,

type Response = A::Response

type Error = BoxError

type Future = Either<A::Future, B::Future>

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

fn call(&mut self, request: Request) -> Self::Future

impl<'pin, A, B> Unpin for Either<A, B> where __Either<'pin, A, B>: Unpin,

Auto Trait Implementations

impl<A, B> RefUnwindSafe for Either<A, B> where A: RefUnwindSafe, B: RefUnwindSafe,

impl<A, B> Send for Either<A, B> where A: Send, B: Send,

impl<A, B> Sync for Either<A, B> where A: Sync, B: Sync,

impl<A, B> UnwindSafe for Either<A, B> where A: UnwindSafe, B: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> FutureExt for T where T: Future + ?Sized,

fn map<U, F>(self, f: F) -> Map<Self, F> where F: FnOnce(Self::Output) -> U,

fn map_into<U>(self) -> MapInto<Self, U> where Self::Output: Into<U>,

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnOnce(Self::Output) -> Fut, Fut: Future,

fn left_future<B>(self) -> Either<Self, B> where B: Future<Output = Self::Output>,

fn right_future<A>(self) -> Either<A, Self> where A: Future<Output = Self::Output>,

fn into_stream(self) -> IntoStream<Self>

fn flatten(self) -> Flatten<Self> where Self::Output: Future,

fn flatten_stream(self) -> FlattenStream<Self> where Self::Output: Stream,

fn fuse(self) -> Fuse<Self>

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnOnce(&Self::Output),

fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe,

fn shared(self) -> Shared<Self> where Self::Output: Clone,

fn boxed<'a>( self) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>> where Self: 'a + Send,

fn boxed_local<'a>( self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where Self: 'a,

fn unit_error(self) -> UnitError<Self>

fn never_error(self) -> NeverError<Self>

fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where Self: Unpin,

fn now_or_never(self) -> Option<Self::Output>

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

impl<F> IntoFuture for F where F: Future,

type Output = <F as Future>::Output

type Future = F

pub fn into_future(self) -> <F as IntoFuture>::Future

impl<T, Request> ServiceExt<Request> for T where T: Service<Request> + ?Sized,

fn ready(&mut self) -> Ready<'_, Self, Request>ⓘNotable traits for Ready<'a, T, Request>impl<'a, T, Request> Future for Ready<'a, T, Request> where T: Service<Request>, type Output = Result<&'a mut T, T::Error>; where Self: Sized,

fn ready_and(&mut self) -> ReadyAnd<'_, Self, Request> where Self: Sized,

fn ready_oneshot(self) -> ReadyOneshot<Self, Request>ⓘNotable traits for ReadyOneshot<T, Request>impl<T, Request> Future for ReadyOneshot<T, Request> where T: Service<Request>, type Output = Result<T, T::Error>; where Self: Sized,

fn oneshot(self, req: Request) -> Oneshot<Self, Request>ⓘNotable traits for Oneshot<S, Req>impl<S, Req> Future for Oneshot<S, Req> where S: Service<Req>, type Output = Result<S::Response, S::Error>; where Self: Sized,

fn call_all<S>(self, reqs: S) -> CallAll<Self, S> where Self: Sized, Self::Error: Into<BoxError>, S: Stream<Item = Request>,

fn and_then<F>(self, f: F) -> AndThen<Self, F> where Self: Sized, F: Clone,

fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F> where Self: Sized, F: FnOnce(Self::Response) -> Response + Clone,

fn map_err<F, Error>(self, f: F) -> MapErr<Self, F> where Self: Sized, F: FnOnce(Self::Error) -> Error + Clone,

fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F> where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Result<Response, Error> + Clone,

fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F> where Self: Sized, F: FnMut(NewRequest) -> Request + Clone,

fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F> where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Fut + Clone, Fut: Future<Output = Result<Response, Error>>,

fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F> where Self: Sized, F: FnMut(Self::Future) -> Fut, Error: From<Self::Error>, Fut: Future<Output = Result<Response, Error>>,

impl<T> ToOwned for T where T: Clone,

type Owned = T

fn clone(&self) -> Either<A, B>ⓘ
Notable traits for Either<A, B>
`impl<A, B, T, AE, BE> Future for Either<A, B> where A: Future<Output = Result<T, AE>>, AE: Into<BoxError>, B: Future<Output = Result<T, BE>>, BE: Into<BoxError>, type Output = Result<T, BoxError>;`

impl<A, B, T, AE, BE> Future for Either<A, B> where
A: Future<Output = Result<T, AE>>,
AE: Into<BoxError>,
B: Future<Output = Result<T, BE>>,
BE: Into<BoxError>,

impl<S, A, B> Layer<S> for Either<A, B> where
A: Layer<S>,
B: Layer<S>,

impl<A, B, Request> Service<Request> for Either<A, B> where
A: Service<Request>,
A::Error: Into<BoxError>,
B: Service<Request, Response = A::Response>,
B::Error: Into<BoxError>,

impl<'pin, A, B> Unpin for Either<A, B> where
__Either<'pin, A, B>: Unpin,

impl<A, B> RefUnwindSafe for Either<A, B> where
A: RefUnwindSafe,
B: RefUnwindSafe,

impl<A, B> Send for Either<A, B> where
A: Send,
B: Send,

impl<A, B> Sync for Either<A, B> where
A: Sync,
B: Sync,

impl<A, B> UnwindSafe for Either<A, B> where
A: UnwindSafe,
B: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T> FutureExt for T where
T: Future + ?Sized,

fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U,

fn map_into<U>(self) -> MapInto<Self, U> where
Self::Output: Into<U>,

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,

fn left_future<B>(self) -> Either<Self, B> where
B: Future<Output = Self::Output>,

fn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>,

fn flatten(self) -> Flatten<Self> where
Self::Output: Future,

fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output),

fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,

fn shared(self) -> Shared<Self> where
Self::Output: Clone,

fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>> where
Self: 'a + Send,

fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where
Self: 'a,

fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,

impl<T, U> Into<U> for T where
U: From<T>,

impl<F> IntoFuture for F where
F: Future,

impl<T, Request> ServiceExt<Request> for T where
T: Service<Request> + ?Sized,

fn ready(&mut self) -> Ready<'_, Self, Request>ⓘ
Notable traits for Ready<'a, T, Request>
`impl<'a, T, Request> Future for Ready<'a, T, Request> where T: Service<Request>, type Output = Result<&'a mut T, T::Error>;`
where
Self: Sized,

fn ready_and(&mut self) -> ReadyAnd<'_, Self, Request> where
Self: Sized,

fn ready_oneshot(self) -> ReadyOneshot<Self, Request>ⓘ
Notable traits for ReadyOneshot<T, Request>
`impl<T, Request> Future for ReadyOneshot<T, Request> where T: Service<Request>, type Output = Result<T, T::Error>;`
where
Self: Sized,

fn oneshot(self, req: Request) -> Oneshot<Self, Request>ⓘ
Notable traits for Oneshot<S, Req>
`impl<S, Req> Future for Oneshot<S, Req> where S: Service<Req>, type Output = Result<S::Response, S::Error>;`
where
Self: Sized,

fn call_all<S>(self, reqs: S) -> CallAll<Self, S> where
Self: Sized,
Self::Error: Into<BoxError>,
S: Stream<Item = Request>,

fn and_then<F>(self, f: F) -> AndThen<Self, F> where
Self: Sized,
F: Clone,

fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F> where
Self: Sized,
F: FnOnce(Self::Response) -> Response + Clone,

fn map_err<F, Error>(self, f: F) -> MapErr<Self, F> where
Self: Sized,
F: FnOnce(Self::Error) -> Error + Clone,

fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F> where
Self: Sized,
Error: From<Self::Error>,
F: FnOnce(Result<Self::Response, Self::Error>) -> Result<Response, Error> + Clone,

fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F> where
Self: Sized,
F: FnMut(NewRequest) -> Request + Clone,

fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F> where
Self: Sized,
Error: From<Self::Error>,
F: FnOnce(Result<Self::Response, Self::Error>) -> Fut + Clone,
Fut: Future<Output = Result<Response, Error>>,

fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F> where
Self: Sized,
F: FnMut(Self::Future) -> Fut,
Error: From<Self::Error>,
Fut: Future<Output = Result<Response, Error>>,

impl<T> ToOwned for T where
T: Clone,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<F, T, E> TryFuture for F where
F: Future<Output = Result<T, E>> + ?Sized,

pub fn try_poll(
self: Pin<&mut F>,
cx: &mut Context<'_>
) -> Poll<<F as Future>::Output>

impl<Fut> TryFutureExt for Fut where
Fut: TryFuture + ?Sized,

fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnOnce(Self::Ok) -> T,

fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E> where
F: FnOnce(Self::Ok) -> T,
E: FnOnce(Self::Error) -> T,

fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnOnce(Self::Error) -> E,

fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,

fn ok_into<U>(self) -> OkInto<Self, U> where
Self::Ok: Into<U>,

fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,

fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,

fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnOnce(&Self::Ok),

fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnOnce(&Self::Error),

fn try_flatten(self) -> TryFlatten<Self, Self::Ok> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,

fn try_flatten_stream(self) -> TryFlattenStream<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error,

fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> where
F: FnOnce(Self::Error) -> Self::Ok,

fn try_poll_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<Self::Ok, Self::Error>> where
Self: Unpin,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

impl<V, T> VZip<V> for T where
V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,