Struct Task

pub struct Task<'t, T> { /* private fields */ }

An asynchronous result which may be evaluated with .await, or by using blocking operations with an optional timeout.

Implementations

impl<'t, T> Task<'t, T>

pub fn from_poll<F>(f: F) -> Self

where F: FnMut(&mut Context<'_>) -> Poll<T> + Send + 't,

Create a new Task from a function returning Poll<T>. If the function is already boxed, then it would be more efficient to use Task::from.

pub fn from_future<F>(f: F) -> Self

where F: Future<Output = T> + Send + 't,

Create a new Task from a Future<T>. If the future is already boxed, then it would be more efficient to use Task::from.

pub fn from_value(result: T) -> Self

where T: Send + 't,

Create a new Task from a result value.

pub fn map<'m, F, R>(self, f: F) -> Task<'m, R>

where F: Fn(T) -> R + Send + 'm, T: 'm, 't: 'm,

Map the result of the Task using a transformation function.

pub fn wait(self) -> T

Resolve the Task to its result, parking the current thread until the result is available.

pub fn wait_deadline(self, expire: Instant) -> Result<T, Self>

Resolve the Task to its result, parking the current thread until the result is available or the deadline is reached. If a timeout occurs then the Err result will contain the original Task.

pub fn wait_timeout(self, timeout: Duration) -> Result<T, Self>

Resolve the Task to its result, parking the current thread until the result is available or the timeout expires. If a timeout does occur then the Err result will contain the original Task.

impl<'t, T, E> Task<'t, Result<T, E>>

pub fn map_ok<'m, F, R>(self, f: F) -> Task<'m, Result<R, E>>

where F: Fn(T) -> R + Send + 'm, T: 'm, E: 'm, 't: 'm,

A helper method to map the Ok(T) result of the Task<Result<T, E>> using a transformation function.

pub fn map_err<'m, F, R>(self, f: F) -> Task<'m, Result<T, R>>

where F: Fn(E) -> R + Send + 'm, T: 'm, E: 'm, 't: 'm,

A helper method to map the Err(E) result of the Task<Result<T, E>> using a transformation function.

Trait Implementations

impl<T> Debug for Task<'_, T>

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

Formats the value using the given formatter.

impl<'t, T> From<Box<dyn FnMut(&mut Context<'_>) -> Poll<T> + Send + 't>> for Task<'t, T>

fn from(poll: PollFn<'t, T>) -> Self

Converts to this type from the input type.

impl<'t, T> From<Pin<Box<dyn Future<Output = T> + Send + 't>>> for Task<'t, T>

fn from(fut: BoxFuture<'t, T>) -> Self

Converts to this type from the input type.

impl<'t, T: Send + 't> From<Receiver<T>> for Task<'t, Result<T, RecvError>>

fn from(receiver: Receiver<T>) -> Self

Converts to this type from the input type.

impl<'t, T> Future for Task<'t, T>

type Output = T

The type of value produced on completion.

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

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

impl<T> PartialEq for Task<'_, T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for Task<'_, T>