Enum Promise 

pub enum Promise<T, E>
where
    T: Unpin,
    E: PromiseRejection,
{
    Pending(BoxedPromiseFuture<T, E>),
    Resolved(T),
    Rejected(E),
    Consumed,
}

Variants

Pending(BoxedPromiseFuture<T, E>)

Resolved(T)

Rejected(E)

Consumed

Implementations

impl<T, E> Promise<T, E>

where T: Send + Unpin + 'static, E: PromiseRejection,

pub fn all<I>(promises: I) -> Promise<Vec<T>, E>

where I: IntoIterator<Item = Self>,

impl<T, E> Promise<T, E>

where T: Send + Unpin + 'static, E: PromiseRejection,

pub fn any<I>(promises: I) -> Promise<T, Vec<E>>

where I: IntoIterator<Item = Self>,

impl<T, E> Promise<T, E>

where T: Send + Unpin + 'static, E: PromiseRejection,

pub fn catch<TO, EO, F, Fut>(self, recover: F) -> Promise<TO, EO>

where TO: From<T> + Unpin + 'static, EO: PromiseRejection + 'static, F: FnOnce(E) -> Fut + Send + 'static, Fut: Future<Output = Result<TO, EO>> + Send + 'static,

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub fn consume(&mut self) -> Option<Result<T, E>>

If settled, consumes and returns the result. Returns None if still pending.

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub const fn is_consumed(&self) -> bool

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub const fn is_pending(&self) -> bool

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub const fn is_ready(&self) -> bool

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub const fn is_rejected(&self) -> bool

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub const fn is_resolved(&self) -> bool

impl<T, E> Promise<T, E>

where T: Send + Unpin + 'static, E: PromiseRejection,

pub fn map<TO, F, Fut>(self, f: F) -> Promise<TO, E>

where TO: Unpin + 'static, F: FnOnce(T) -> Fut + Send + 'static, Fut: Future<Output = TO> + Send + 'static,

impl<T, E> Promise<T, E>

where T: Send + Unpin + 'static, E: PromiseRejection,

pub fn map_err<EO, F, Fut>(self, f: F) -> Promise<T, EO>

where EO: PromiseRejection + 'static, F: FnOnce(E) -> Fut + Send + 'static, Fut: Future<Output = EO> + Send + 'static,

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

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

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

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub fn pending(&mut self, cx: &mut Context<'_>) -> bool

Polls the promise’s inner future if pending. Returns true if the promise is still pending.

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub fn pending_sync(&mut self) -> bool

Polls the promise’s inner future using a no-op waker. Returns true if the promise is still pending.

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub fn poll(&mut self, cx: &mut Context<'_>)

Attempts to advance this Promise using the provided execution Context.

This performs exactly one poll of the underlying future.

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub fn poll_sync(&mut self)

Attempts to advance this Promise immediately on the current thread.

This performs exactly one poll of the underlying future using a no-op waker.

Wakes triggered during this synchronous poll are ignored. Execution will effectively resume only when the Promise is polled again by a real executor.

impl<T, E> Promise<T, E>

where T: Send + Unpin + 'static, E: PromiseRejection,

pub fn race<I>(promises: I) -> Self

where I: IntoIterator<Item = Self>,

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub fn ready(&mut self, cx: &mut Context<'_>) -> bool

Polls the promise’s inner future if pending. Returns true if the promise is now resolved or rejected.

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub fn ready_sync(&mut self) -> bool

Polls the promise’s inner future using a no-op waker. Returns true if the promise is now resolved or rejected.

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub const fn reject(err: E) -> Self

impl<T, E> Promise<T, E>

where T: Unpin, E: PromiseRejection,

pub const fn resolve(value: T) -> Self

impl<T, E> Promise<T, E>

where T: Send + Unpin + 'static, E: PromiseRejection,

pub fn then<TO, EO, F, Fut>(self, f: F) -> Promise<TO, EO>

where TO: Unpin + 'static, EO: PromiseRejection + From<E> + 'static, F: FnOnce(T) -> Fut + Send + 'static, Fut: Future<Output = Result<TO, EO>> + Send + 'static,

impl<T, E> Promise<T, WrappedPromiseRejection<E>>

where T: Unpin, E: Send + Unpin + 'static,

pub fn wrap(future: impl Future<Output = Result<T, E>> + Send + 'static) -> Self

Trait Implementations

impl<T, E> Debug for Promise<T, E>

where T: Unpin + Debug, E: PromiseRejection + Debug,

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

Formats the value using the given formatter.

impl<T, E> Default for Promise<T, E>

where T: Default + Unpin, E: PromiseRejection,

fn default() -> Self

Returns the “default value” for a type.

impl<T, E> Future for Promise<T, E>

where T: Unpin, E: PromiseRejection,

type Output = Result<T, E>

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.