Struct asynchronous::Promise

pub struct Promise<T, E> {
    // some fields omitted
}

Stores a result of previous execution tasks. T : Type of value returned E : Type of error returned

Methods

impl<T, E> Promise<T, E> where T: Send + 'static, E: Send + 'static

fn new<F>(f: F) -> Promise<T, E> where F: Send + 'static + FnOnce() -> Result<T, E>

Execute a task inmediatly and returns its Promise.

let promise = asynchronous::Promise::new(|| {
   // Do something  
   if true { Ok("value a")} else { Err("Error description") }
});

fn sync(self) -> Result<T, E>

Syncronizes the execution with the caller, and returns its value.

use asynchronous::Promise;
 
let promise_a = Promise::<_,&str>::new(|| {
   // Do something  
   Ok("value a")
});
let promise_b = Promise::<_,&str>::new(|| {    
   // Do something 
   Ok("value b")
});
// Do something
assert_eq!(promise_a.sync(), Ok("value a"));
assert_eq!(promise_b.sync(), Ok("value b"));

fn all(vector: Vec<Promise<T, E>>) -> Promise<Vec<T>, Vec<Result<T, E>>>

Creates a new promise with the result of all other Promises in the vector.

use asynchronous::Promise;
 
let mut vec_promises = Vec::new();
for i in 0..5 { vec_promises.push(Promise::<_,&str>::new(move || Ok(i) )) }
let res = Promise::all(vec_promises).sync().unwrap();
assert_eq!(res, vec![0,1,2,3,4]);

fn then<TT, F>(self, f: F) -> Promise<TT, E> where F: Send + 'static + FnOnce(T) -> Result<TT, E>, TT: Send + 'static

Executes a new task if the result of the previous promise is Ok. It may return a new type in a correct result (Ok), but it must return the same type of error of its previous promise.

asynchronous::Promise::new(|| {
   Ok(1.23)
}).then(|res| {
   assert_eq!(res, 1.23);
   Ok(34)
}).then(|res| {
   assert_eq!(res, 34);
   if true { Ok(res) } else { Err("Final error")}
}).sync();

fn fail<F>(self, f: F) -> Promise<T, E> where F: Send + 'static + FnOnce(E) -> Result<T, E>

Executes a new task if the result of the previous promise is Err. It may return a new type in a correct result (Ok), but it must return the same type of error of its previous promise.

asynchronous::Promise::new(|| {
   Err(32)
}).then(|res| {
   unreachable!();
   Ok(res)
}).fail(|err| {
   assert_eq!(err, 32);
   Ok("Value Ok")
}).sync();

fn finally<FT, FE>(self, ft: FT, fe: FE) where FT: Send + 'static + FnOnce(T), FE: Send + 'static + FnOnce(E)

Executes only one of the two functions received depending on the result of the previous promise (Ok or Err). It doesn't return anything and it's completly asynchronous.

asynchronous::Promise::new(|| {
   std::thread::sleep_ms(100);
   if true { Ok(32) } else { Err("Error txt") }
}).finally(|res| { 
   assert_eq!(res, 32);
}, |err|{
   unreachable!();        
   assert_eq!(err, "Error txt");
});

let a = 2 + 3;  // This line is executed before the above Promise
 

fn finally_sync<FT, FE>(self, ft: FT, fe: FE) where FT: Send + 'static + FnOnce(T), FE: Send + 'static + FnOnce(E)

Executes only one of the two functions received depending on the result of the previous promise (Ok or Err). It doesn't return anything, but it's synchronized with the caller

use asynchronous::Promise;
 
Promise::new(|| {
   std::thread::sleep_ms(100);
   if true { Ok(32) } else { Err("Error txt") }
}).finally_sync(|res| { 
   assert_eq!(res, 32);
}, |err|{
   unreachable!();        
   assert_eq!(err, "Error txt");
});    

let a = 2 + 3;  // This line is executed after the above Promise