Struct tracing_futures::WithDispatch [−][src]
std
only.A future, stream, sink, or executor that has been instrumented with a
tracing
subscriber.
Implementations
impl WithDispatch<Runtime>
[src]
pub fn spawn<F>(&mut self, future: F) -> &mut Self where
F: Future<Item = (), Error = ()> + Send + 'static,
[src]
F: Future<Item = (), Error = ()> + Send + 'static,
Spawn a future onto the Tokio runtime, in the context of this
WithDispatch
's trace dispatcher.
This spawns the given future onto the runtime's executor, usually a thread pool. The thread pool is then responsible for polling the future until it completes.
This method simply wraps a call to tokio::runtime::Runtime::spawn
,
instrumenting the spawned future beforehand.
pub fn block_on<F, R, E>(&mut self, future: F) -> Result<R, E> where
F: Send + 'static + Future<Item = R, Error = E>,
R: Send + 'static,
E: Send + 'static,
[src]
F: Send + 'static + Future<Item = R, Error = E>,
R: Send + 'static,
E: Send + 'static,
Run a future to completion on the Tokio runtime, in the context of this
WithDispatch
's trace dispatcher.
This runs the given future on the runtime, blocking until it is complete, and yielding its resolved result. Any tasks or timers which the future spawns internally will be executed on the runtime.
This method should not be called from an asynchronous context.
This method simply wraps a call to tokio::runtime::Runtime::block_on
,
instrumenting the spawned future beforehand.
Panics
This function panics if the executor is at capacity, if the provided future panics, or if called within an asynchronous execution context.
pub fn executor(&self) -> WithDispatch<TaskExecutor>ⓘNotable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
[src]
Notable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
Return a handle to the runtime's executor, in the context of this
WithDispatch
's trace dispatcher.
The returned handle can be used to spawn tasks that run on this runtime.
The instrumented handle functions identically to a
tokio::runtime::TaskExecutor
, but instruments the spawned
futures prior to spawning them.
impl WithDispatch<Runtime>
[src]
pub fn spawn<F>(&mut self, future: F) -> &mut Self where
F: Future<Item = (), Error = ()> + 'static,
[src]
F: Future<Item = (), Error = ()> + 'static,
Spawn a future onto the single-threaded Tokio runtime, in the context
of this WithDispatch
's trace dispatcher.
This method simply wraps a call to current_thread::Runtime::spawn
,
instrumenting the spawned future beforehand.
pub fn block_on<F, R, E>(&mut self, future: F) -> Result<R, E> where
F: 'static + Future<Item = R, Error = E>,
R: 'static,
E: 'static,
[src]
F: 'static + Future<Item = R, Error = E>,
R: 'static,
E: 'static,
Runs the provided future in the context of this WithDispatch
's trace
dispatcher, blocking the current thread until the future completes.
This function can be used to synchronously block the current thread
until the provided future
has resolved either successfully or with an
error. The result of the future is then returned from this function
call.
Note that this function will also execute any spawned futures on the
current thread, but will not block until these other spawned futures
have completed. Once the function returns, any uncompleted futures
remain pending in the Runtime
instance. These futures will not run
until block_on
or run
is called again.
The caller is responsible for ensuring that other spawned futures
complete execution by calling block_on
or run
.
This method simply wraps a call to current_thread::Runtime::block_on
,
instrumenting the spawned future beforehand.
Panics
This function panics if the executor is at capacity, if the provided future panics, or if called within an asynchronous execution context.
pub fn handle(&self) -> WithDispatch<Handle>ⓘNotable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
[src]
Notable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
Get a new handle to spawn futures on the single-threaded Tokio runtime,
in the context of this WithDispatch
's trace dispatcher.
Different to the runtime itself, the handle can be sent to different threads.
The instrumented handle functions identically to a
tokio::runtime::current_thread::Handle
, but the spawned
futures are run in the context of the trace dispatcher.
impl<T> WithDispatch<T>
[src]
pub fn with_dispatch<U>(&self, inner: U) -> WithDispatch<U>ⓘNotable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
[src]
Notable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
Wrap a future, stream, sink or executor with the same subscriber as this WithDispatch.
pub fn dispatch(&self) -> &Dispatch
[src]
Borrows the Dispatch
that this type is instrumented by.
pub fn inner_pin_ref(self: Pin<&Self>) -> Pin<&T>
[src]
std-future
only.Get a pinned reference to the wrapped type.
pub fn inner_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T>
[src]
std-future
only.Get a pinned mutable reference to the wrapped type.
pub fn inner(&self) -> &T
[src]
Borrows the wrapped type.
pub fn inner_mut(&mut self) -> &mut T
[src]
Mutably borrows the wrapped type.
pub fn into_inner(self) -> T
[src]
Consumes the WithDispatch
, returning the wrapped type.
Trait Implementations
impl<T: Clone> Clone for WithDispatch<T>
[src]
fn clone(&self) -> WithDispatch<T>ⓘNotable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
[src]
Notable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T: Debug> Debug for WithDispatch<T>
[src]
impl<T> Executor for WithDispatch<T> where
T: Executor,
[src]
T: Executor,
fn spawn(
&mut self,
future: Box<dyn Future<Error = (), Item = ()> + Send + 'static>
) -> Result<(), SpawnError>
[src]
&mut self,
future: Box<dyn Future<Error = (), Item = ()> + Send + 'static>
) -> Result<(), SpawnError>
pub fn status(&self) -> Result<(), SpawnError>
[src]
impl<T, F> Executor<F> for WithDispatch<T> where
T: Executor<WithDispatch<F>>,
F: Future<Item = (), Error = ()>,
[src]
T: Executor<WithDispatch<F>>,
F: Future<Item = (), Error = ()>,
fn execute(&self, future: F) -> Result<(), ExecuteError<F>>
[src]
impl<T: Future> Future for WithDispatch<T>
[src]
std-future
only.type Output = T::Output
The type of value produced on completion.
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>
[src]
impl<T: Future> Future for WithDispatch<T>
[src]
futures-01
only.type Item = T::Item
The type of value that this future will resolved with if it is successful. Read more
type Error = T::Error
The type of error that this future will resolve with if it fails in a normal fashion. Read more
fn poll(&mut self) -> Poll<Self::Item, Self::Error>
[src]
pub fn wait(self) -> Result<Self::Item, Self::Error>
[src]
pub fn map<F, U>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Item) -> U,
[src]
F: FnOnce(Self::Item) -> U,
pub fn map_err<F, E>(self, f: F) -> MapErr<Self, F> where
F: FnOnce(Self::Error) -> E,
[src]
F: FnOnce(Self::Error) -> E,
pub fn from_err<E>(self) -> FromErr<Self, E> where
E: From<Self::Error>,
[src]
E: From<Self::Error>,
pub fn then<F, B>(self, f: F) -> Then<Self, B, F> where
F: FnOnce(Result<Self::Item, Self::Error>) -> B,
B: IntoFuture,
[src]
F: FnOnce(Result<Self::Item, Self::Error>) -> B,
B: IntoFuture,
pub fn and_then<F, B>(self, f: F) -> AndThen<Self, B, F> where
F: FnOnce(Self::Item) -> B,
B: IntoFuture<Error = Self::Error>,
[src]
F: FnOnce(Self::Item) -> B,
B: IntoFuture<Error = Self::Error>,
pub fn or_else<F, B>(self, f: F) -> OrElse<Self, B, F> where
F: FnOnce(Self::Error) -> B,
B: IntoFuture<Item = Self::Item>,
[src]
F: FnOnce(Self::Error) -> B,
B: IntoFuture<Item = Self::Item>,
pub fn select<B>(self, other: B) -> Select<Self, <B as IntoFuture>::Future> where
B: IntoFuture<Item = Self::Item, Error = Self::Error>,
[src]
B: IntoFuture<Item = Self::Item, Error = Self::Error>,
pub fn select2<B>(self, other: B) -> Select2<Self, <B as IntoFuture>::Future> where
B: IntoFuture,
[src]
B: IntoFuture,
pub fn join<B>(self, other: B) -> Join<Self, <B as IntoFuture>::Future> where
B: IntoFuture<Error = Self::Error>,
[src]
B: IntoFuture<Error = Self::Error>,
pub fn join3<B, C>(
self,
b: B,
c: C
) -> Join3<Self, <B as IntoFuture>::Future, <C as IntoFuture>::Future> where
C: IntoFuture<Error = Self::Error>,
B: IntoFuture<Error = Self::Error>,
[src]
self,
b: B,
c: C
) -> Join3<Self, <B as IntoFuture>::Future, <C as IntoFuture>::Future> where
C: IntoFuture<Error = Self::Error>,
B: IntoFuture<Error = Self::Error>,
pub fn join4<B, C, D>(
self,
b: B,
c: C,
d: D
) -> Join4<Self, <B as IntoFuture>::Future, <C as IntoFuture>::Future, <D as IntoFuture>::Future> where
C: IntoFuture<Error = Self::Error>,
B: IntoFuture<Error = Self::Error>,
D: IntoFuture<Error = Self::Error>,
[src]
self,
b: B,
c: C,
d: D
) -> Join4<Self, <B as IntoFuture>::Future, <C as IntoFuture>::Future, <D as IntoFuture>::Future> where
C: IntoFuture<Error = Self::Error>,
B: IntoFuture<Error = Self::Error>,
D: IntoFuture<Error = Self::Error>,
pub fn join5<B, C, D, E>(
self,
b: B,
c: C,
d: D,
e: E
) -> Join5<Self, <B as IntoFuture>::Future, <C as IntoFuture>::Future, <D as IntoFuture>::Future, <E as IntoFuture>::Future> where
C: IntoFuture<Error = Self::Error>,
E: IntoFuture<Error = Self::Error>,
B: IntoFuture<Error = Self::Error>,
D: IntoFuture<Error = Self::Error>,
[src]
self,
b: B,
c: C,
d: D,
e: E
) -> Join5<Self, <B as IntoFuture>::Future, <C as IntoFuture>::Future, <D as IntoFuture>::Future, <E as IntoFuture>::Future> where
C: IntoFuture<Error = Self::Error>,
E: IntoFuture<Error = Self::Error>,
B: IntoFuture<Error = Self::Error>,
D: IntoFuture<Error = Self::Error>,
pub fn into_stream(self) -> IntoStream<Self>
[src]
pub fn flatten(self) -> Flatten<Self> where
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error: From<Self::Error>,
[src]
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error: From<Self::Error>,
pub fn flatten_stream(self) -> FlattenStream<Self> where
Self::Item: Stream,
<Self::Item as Stream>::Error == Self::Error,
[src]
Self::Item: Stream,
<Self::Item as Stream>::Error == Self::Error,
pub fn fuse(self) -> Fuse<Self>
[src]
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Item),
[src]
F: FnOnce(&Self::Item),
pub fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
[src]
Self: UnwindSafe,
pub fn shared(self) -> Shared<Self>
[src]
impl<T> LocalSpawn for WithDispatch<T> where
T: LocalSpawn,
[src]
T: LocalSpawn,
fn spawn_local_obj(
&self,
future: LocalFutureObj<'static, ()>
) -> Result<(), SpawnError>
[src]
&self,
future: LocalFutureObj<'static, ()>
) -> Result<(), SpawnError>
Spawns a future that will be run to completion.
Errors
The executor may be unable to spawn tasks. Spawn errors should represent relatively rare scenarios, such as the executor having been shut down so that it is no longer able to accept tasks.
fn status_local(&self) -> Result<(), SpawnError>
[src]
Determines whether the executor is able to spawn new tasks.
This method will return Ok
when the executor is likely
(but not guaranteed) to accept a subsequent spawn attempt.
Likewise, an Err
return means that spawn
is likely, but
not guaranteed, to yield an error.
impl<T> Spawn for WithDispatch<T> where
T: Spawn,
[src]
T: Spawn,
fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError>
[src]
Spawns a future that will be run to completion.
Errors
The executor may be unable to spawn tasks. Spawn errors should represent relatively rare scenarios, such as the executor having been shut down so that it is no longer able to accept tasks.
fn status(&self) -> Result<(), SpawnError>
[src]
Determines whether the executor is able to spawn new tasks.
This method will return Ok
when the executor is likely
(but not guaranteed) to accept a subsequent spawn attempt.
Likewise, an Err
return means that spawn
is likely, but
not guaranteed, to yield an error.
impl<T, F> TypedExecutor<F> for WithDispatch<T> where
T: TypedExecutor<WithDispatch<F>>,
[src]
T: TypedExecutor<WithDispatch<F>>,
fn spawn(&mut self, future: F) -> Result<(), SpawnError>
[src]
fn status(&self) -> Result<(), SpawnError>
[src]
impl<'pin, T> Unpin for WithDispatch<T> where
__WithDispatch<'pin, T>: Unpin,
[src]
__WithDispatch<'pin, T>: Unpin,
Auto Trait Implementations
impl<T> !RefUnwindSafe for WithDispatch<T>
[src]
impl<T> Send for WithDispatch<T> where
T: Send,
[src]
T: Send,
impl<T> Sync for WithDispatch<T> where
T: Sync,
[src]
T: Sync,
impl<T> !UnwindSafe for WithDispatch<T>
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T> FutureExt for T where
T: Future + ?Sized,
[src]
T: Future + ?Sized,
impl<T> FutureExt for T where
T: Future + ?Sized,
T: Future + ?Sized,
pub fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U,
F: FnOnce(Self::Output) -> U,
pub fn map_into<U>(self) -> MapInto<Self, U> where
Self::Output: Into<U>,
Self::Output: Into<U>,
pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
pub fn left_future<B>(self) -> Either<Self, B> where
B: Future<Output = Self::Output>,
B: Future<Output = Self::Output>,
pub fn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>,
A: Future<Output = Self::Output>,
pub fn into_stream(self) -> IntoStream<Self>
pub fn flatten(self) -> Flatten<Self> where
Self::Output: Future,
Self::Output: Future,
pub fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
Self::Output: Stream,
pub fn fuse(self) -> Fuse<Self>
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output),
F: FnOnce(&Self::Output),
pub fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
Self: UnwindSafe,
pub fn shared(self) -> Shared<Self> where
Self::Output: Clone,
Self::Output: Clone,
pub fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)
pub fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>> where
Self: Send + 'a,
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>> where
Self: Send + 'a,
pub fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where
Self: 'a,
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where
Self: 'a,
pub fn unit_error(self) -> UnitError<Self>
pub fn never_error(self) -> NeverError<Self>
pub fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
Self: Unpin,
pub fn now_or_never(self) -> Option<Self::Output>
impl<T> Instrument for T
[src]
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T: Future> Future for Instrumented<T> type Output = T::Output;
[src]
Notable traits for Instrumented<T>
impl<T: Future> Future for Instrumented<T> type Output = T::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T: Future> Future for Instrumented<T> type Output = T::Output;
[src]
Notable traits for Instrumented<T>
impl<T: Future> Future for Instrumented<T> type Output = T::Output;
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<F> IntoFuture for F where
F: Future,
[src]
F: Future,
type Output = <F as Future>::Output
The output that the future will produce on completion.
type Future = F
Which kind of future are we turning this into?
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]
impl<F> IntoFuture for F where
F: Future,
[src]
F: Future,
type Future = F
The future that this type can be converted into.
type Item = <F as Future>::Item
The item that the future may resolve with.
type Error = <F as Future>::Error
The error that the future may resolve with.
pub fn into_future(self) -> F
[src]
impl<Sp> LocalSpawnExt for Sp where
Sp: LocalSpawn + ?Sized,
Sp: LocalSpawn + ?Sized,
pub fn spawn_local<Fut>(&self, future: Fut) -> Result<(), SpawnError> where
Fut: Future<Output = ()> + 'static,
Fut: Future<Output = ()> + 'static,
pub fn spawn_local_with_handle<Fut>(
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: Future + 'static,
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: Future + 'static,
impl<Sp> SpawnExt for Sp where
Sp: Spawn + ?Sized,
Sp: Spawn + ?Sized,
pub fn spawn<Fut>(&self, future: Fut) -> Result<(), SpawnError> where
Fut: Future<Output = ()> + Send + 'static,
Fut: Future<Output = ()> + Send + 'static,
pub fn spawn_with_handle<Fut>(
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: Future + Send + 'static,
<Fut as Future>::Output: Send,
&self,
future: Fut
) -> Result<RemoteHandle<<Fut as Future>::Output>, SpawnError> where
Fut: Future + Send + 'static,
<Fut as Future>::Output: Send,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<F, T, E> TryFuture for F where
F: Future<Output = Result<T, E>> + ?Sized,
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
pub fn try_poll(
self: Pin<&mut F>,
cx: &mut Context<'_>
) -> Poll<<F as Future>::Output>
self: Pin<&mut F>,
cx: &mut Context<'_>
) -> Poll<<F as Future>::Output>
impl<Fut> TryFutureExt for Fut where
Fut: TryFuture + ?Sized,
Fut: TryFuture + ?Sized,
pub fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok> where
Self::Ok: Sink<Item>,
<Self::Ok as Sink<Item>>::Error == Self::Error,
Self::Ok: Sink<Item>,
<Self::Ok as Sink<Item>>::Error == Self::Error,
pub fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnOnce(Self::Ok) -> T,
F: FnOnce(Self::Ok) -> T,
pub fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E> where
E: FnOnce(Self::Error) -> T,
F: FnOnce(Self::Ok) -> T,
E: FnOnce(Self::Error) -> T,
F: FnOnce(Self::Ok) -> T,
pub fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnOnce(Self::Error) -> E,
F: FnOnce(Self::Error) -> E,
pub fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
Self::Error: Into<E>,
pub fn ok_into<U>(self) -> OkInto<Self, U> where
Self::Ok: Into<U>,
Self::Ok: Into<U>,
pub fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
pub fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
pub fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnOnce(&Self::Ok),
F: FnOnce(&Self::Ok),
pub fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnOnce(&Self::Error),
F: FnOnce(&Self::Error),
pub fn try_flatten(self) -> TryFlatten<Self, Self::Ok> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
pub fn try_flatten_stream(self) -> TryFlattenStream<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error,
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error,
pub fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> where
F: FnOnce(Self::Error) -> Self::Ok,
F: FnOnce(Self::Error) -> Self::Ok,
pub fn into_future(self) -> IntoFuture<Self>
pub fn try_poll_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<Self::Ok, Self::Error>> where
Self: 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>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> WithSubscriber for T
[src]
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
where
S: Into<Dispatch>,
[src]
Notable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
S: Into<Dispatch>,
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;
[src]
Notable traits for WithDispatch<T>
impl<T: Future> Future for WithDispatch<T> type Output = T::Output;