Struct AsyncOption 

pub struct AsyncOption<T: 'static> { /* private fields */ }

Implementations

impl<T> AsyncOption<T>

pub fn new(value: Option<T>) -> AsyncOption<T>

Create a new asynchronous option.

Examples

use tokio::runtime::Runtime;

let runtime = Runtime::new().unwrap();
let result = runtime.block_on(async {
    let res: AsyncOption<u8> = AsyncOption::new(Some(1));
    res.await
});
println!("{:?}", result);

pub fn raw<V: Future<Output = Option<T>> + 'static>(value: V) -> AsyncOption<T>

Create a new asynchronous option from a raw future.

Examples

use tokio::runtime::Runtime;

let runtime = Runtime::new().unwrap();
let result = runtime.block_on(async {
    let res: AsyncOption<u8> = AsyncOption::raw(async { Some(1) });
    res.await
});
println!("{:?}", result);

pub fn and<U>( self, optb: impl Future<Output = Option<U>> + 'static, ) -> AsyncOption<U>

pub fn and_then<F, V>(self, f: impl FnOnce(T) -> F + 'static) -> AsyncOption<V>

where F: Future<Output = Option<V>> + 'static, V: 'static,

pub fn or( self, optb: impl Future<Output = Option<T>> + 'static, ) -> AsyncOption<T>

pub fn or_else<F>(self, f: impl FnOnce() -> F + 'static) -> AsyncOption<T>

where F: Future<Output = Option<T>>,

pub fn xor( self, optb: impl Future<Output = Option<T>> + 'static, ) -> AsyncOption<T>

pub fn ok_or<E: 'static>( self, err: impl Future<Output = E> + 'static, ) -> AsyncResult<T, E>

pub fn ok_or_else<E, F>( self, f: impl FnOnce() -> F + 'static, ) -> AsyncResult<T, E>

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

pub fn map<F, V>(self, f: impl FnOnce(T) -> F + 'static) -> AsyncOption<V>

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

pub fn zip<U>( self, other: impl Future<Output = Option<U>> + 'static, ) -> AsyncOption<(T, U)>

pub fn zip_with<U, F, R>( self, other: impl Future<Output = Option<U>> + 'static, f: impl FnOnce(T, U) -> F + 'static, ) -> AsyncOption<R>

where F: Future<Output = R>,

pub fn filter<F>(self, predicate: impl FnOnce(&T) -> F + 'static) -> Self

where F: Future<Output = bool>,

pub fn inspect<F>(self, f: impl FnOnce(&T) -> F + 'static) -> Self

where F: Future<Output = ()> + 'static,

pub async fn map_or<U, F>(self, default: F, f: impl FnOnce(T) -> F) -> U

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

pub async fn map_or_else<U, F>( self, default: impl FnOnce() -> F, f: impl FnOnce(T) -> F, ) -> U

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

pub async fn is_none(self) -> bool

pub async fn is_some(self) -> bool

pub async fn is_some_and<F>(self, f: impl FnOnce(T) -> F) -> bool

where F: Future<Output = bool>,

pub async fn is_none_or<F>(self, f: impl FnOnce(T) -> F) -> bool

where F: Future<Output = bool>,

impl<T, E> AsyncOption<AsyncResult<T, E>>

pub fn transpose(self) -> AsyncResult<Option<T>, E>

This operation does not return an AsyncOption because it has to await both the result and the option, thus creating another AsyncOption is only an additional burden.

impl<T, E> AsyncOption<Result<T, E>>

pub fn transpose(self) -> AsyncResult<Option<T>, E>

This operation does not return an AsyncOption because it has to await the option, thus creating another AsyncOption is only an additional burden.

impl<T> AsyncOption<AsyncOption<T>>

pub fn flatten(self) -> AsyncOption<T>

impl<T> AsyncOption<Option<T>>

pub fn flatten(self) -> AsyncOption<T>

Trait Implementations

impl<T: 'static> From<Option<T>> for AsyncOption<T>

fn from(value: Option<T>) -> Self

Converts to this type from the input type.

impl<T> Future for AsyncOption<T>

type Output = Option<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.