Struct AsyncTask

pub struct AsyncTask<T>
where
    T: NotResult,
{ /* private fields */ }

Generic async task wrapper for single operations

This wraps a oneshot::Receiver and implements Future to provide a concrete return type instead of boxed futures or async fn.

IMPORTANT: AsyncTask must never return Result types - all error handling should be done internally before creating the AsyncTask.

Implementations

impl<T> AsyncTask<T>

where T: NotResult,

pub fn new(receivers: ZeroOneOrMany<Receiver<T>>) -> Self

where T: Send + 'static,

Create a new AsyncTask from ZeroOneOrMany receivers

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

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

Create an AsyncTask from a future

pub fn from_value(value: T) -> Self

where T: Send + 'static,

Create an AsyncTask from a value

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

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Create an AsyncTask that spawns a blocking task

Trait Implementations

impl<T> Future for AsyncTask<T>

where T: NotResult,

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: Send + 'static + NotResult> FutureExt<T> for AsyncTask<T>

fn map<U>(self, f: impl FnOnce(T) -> U + Send + 'static) -> AsyncTask<U>

where U: Send + 'static + NotResult,

Maps the success value of the future to a new type using the provided function.

fn on_ok<U>(self, f: impl FnOnce(T) -> U + Send + 'static) -> AsyncTask<U>

where U: Send + 'static + NotResult,

Executes a function when the future completes successfully.

fn on_error<U>( self, f: impl FnOnce(RecvError) -> U + Send + 'static, ) -> AsyncTask<U>

where U: Send + 'static + NotResult, T: Into<U>,

Executes a function when the future encounters an error.

fn on_result<U>( self, f: impl FnOnce(Result<T, RecvError>) -> U + Send + 'static, ) -> AsyncTask<U>

where U: Send + 'static + NotResult,

Handles both success and error cases with a result handler.

fn map_ok<U>(self, f: impl FnOnce(T) -> U + Send + 'static) -> AsyncTask<U>

where U: Send + 'static + NotResult,

Maps the success value while preserving error state.

fn tap_ok(self, f: impl FnOnce(&T) + Send + 'static) -> AsyncTask<T>

Applies a function to the success value without consuming it.

fn tap_err(self, f: impl FnOnce(&RecvError) + Send + 'static) -> AsyncTask<T>

Applies a function to the error value without consuming it.