Trait eventual::Async
[−]
[src]
pub trait Async: Send + 'static + Sized { type Value: Send + 'static; type Error: Send + 'static; type Cancel: Cancel<Self>; fn is_ready(&self) -> bool; fn is_err(&self) -> bool; fn poll(self) -> Result<AsyncResult<Self::Value, Self::Error>, Self>; fn ready<F>(self, f: F) -> Self::Cancel where F: FnOnce(Self) + Send + 'static; fn expect(self) -> AsyncResult<Self::Value, Self::Error> { ... } fn receive<F>(self, f: F) where F: FnOnce(AsyncResult<Self::Value, Self::Error>) + Send + 'static { ... } fn await(self) -> AsyncResult<Self::Value, Self::Error> { ... } fn fire(self) { ... } fn and<U: Async<Error=Self::Error>>(self, next: U) -> Future<U::Value, Self::Error> { ... } fn and_then<F, U: Async<Error=Self::Error>>(self, f: F) -> Future<U::Value, Self::Error> where F: FnOnce(Self::Value) -> U + Send + 'static, U::Value: Send + 'static { ... } fn or<A>(self, alt: A) -> Future<Self::Value, A::Error> where A: Async<Value=Self::Value> { ... } fn or_else<F, A>(self, f: F) -> Future<Self::Value, A::Error> where F: FnOnce(Self::Error) -> A + Send + 'static, A: Async<Value=Self::Value> { ... } }
A value representing an asynchronous computation
Associated Types
Required Methods
fn is_ready(&self) -> bool
Returns true if expect
will succeed.
fn is_err(&self) -> bool
Returns true if the async value is ready and has failed
fn poll(self) -> Result<AsyncResult<Self::Value, Self::Error>, Self>
Get the underlying value if present
fn ready<F>(self, f: F) -> Self::Cancel where F: FnOnce(Self) + Send + 'static
Invokes the given function when the Async instance is ready to be consumed.
Provided Methods
fn expect(self) -> AsyncResult<Self::Value, Self::Error>
Get the underlying value if present, panic otherwise
fn receive<F>(self, f: F) where F: FnOnce(AsyncResult<Self::Value, Self::Error>) + Send + 'static
Invoke the callback with the resolved Async
result.
fn await(self) -> AsyncResult<Self::Value, Self::Error>
Blocks the thread until the async value is complete and returns the result.
fn fire(self)
Trigger the computation without waiting for the result
fn and<U: Async<Error=Self::Error>>(self, next: U) -> Future<U::Value, Self::Error>
This method returns a future whose completion value depends on the completion value of the original future.
If the original future completes with an error, the future returned by this method completes with that error.
If the original future completes successfully, the future returned by
this method completes with the completion value of next
.
fn and_then<F, U: Async<Error=Self::Error>>(self, f: F) -> Future<U::Value, Self::Error> where F: FnOnce(Self::Value) -> U + Send + 'static, U::Value: Send + 'static
This method returns a future whose completion value depends on the completion value of the original future.
If the original future completes with an error, the future returned by this method completes with that error.
If the original future completes successfully, the callback to this method is called with the value, and the callback returns a new future. The future returned by this method then completes with the completion value of that returned future.
use eventual::*; let f = Future::of(1337); f.and_then(|v| { assert_eq!(v, 1337); Ok(1007) }).and_then(|v| { assert_eq!(v, 1007) }).await(); let e = Future::<(), &'static str>::error("failed"); e.and_then(|v| { panic!("unreachable"); Ok(()) }).await();
fn or<A>(self, alt: A) -> Future<Self::Value, A::Error> where A: Async<Value=Self::Value>
This method returns a future whose completion value depends on the completion value of the original future.
If the original future completes successfully, the future returned by this method will complete with that value.
If the original future completes with an error, the future returned by
this method will complete with the completion value of the alt
future
passed in. That can be either a success or error.
fn or_else<F, A>(self, f: F) -> Future<Self::Value, A::Error> where F: FnOnce(Self::Error) -> A + Send + 'static, A: Async<Value=Self::Value>
This method returns a future whose completion value depends on the completion value of the original future.
If the original future completes successfully, the future returned by this method will complete with that value.
If the original future completes with an error, this method will invoke the callback passed to the method, which should return a future. The future returned by this method will complete with the completion value of that future. That can be either a success or error.
Implementors
impl<T: Send + 'static, E: Send + 'static> Async for Future<T, E>
impl<T: Send + 'static, E: Send + 'static> Async for Complete<T, E>
impl<T: Send + 'static, E: Send + 'static> Async for Stream<T, E>
impl<T: Send + 'static, E: Send + 'static> Async for Sender<T, E>
impl<T: Send + 'static, E: Send + 'static> Async for BusySender<T, E>
impl<T: Send + 'static, E: Send + 'static> Async for Result<T, E>
impl Async for ()