pub struct Promise<T, E> { /* private fields */ }
Expand description
Stores a result of previous execution tasks. T : Type of value returned E : Type of error returned
Implementations§
Source§impl<T, E> Promise<T, E>
impl<T, E> Promise<T, E>
Sourcepub fn new<F>(f: F) -> Promise<T, E>
pub fn new<F>(f: F) -> Promise<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") }
});
Sourcepub fn sync(self) -> Result<T, E>
pub 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"));
Sourcepub fn all(vector: Vec<Promise<T, E>>) -> Promise<Vec<T>, Vec<Result<T, E>>>
pub 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]);
Sourcepub fn then<TT, EE, FT, FE>(self, ft: FT, fe: FE) -> Promise<TT, EE>
pub fn then<TT, EE, FT, FE>(self, ft: FT, fe: FE) -> Promise<TT, EE>
Executes only one of the two functions received depending on the result of the previous promise (Ok or Err). Returns a new Promise
let r = asynchronous::Promise::new(|| {
if false { Ok(1.23) } else { Err("Final error")}
}).then(|res| {
unreachable!();
assert_eq!(res, 1.23);
Ok(34)
}, |err| {
assert_eq!(err, "Final error");
if true { Ok(35) } else { Err(44u64)}
}).sync();
assert_eq!(r, Ok(35));
Sourcepub fn chain<TT, EE, F>(self, f: F) -> Promise<TT, EE>
pub fn chain<TT, EE, F>(self, f: F) -> Promise<TT, EE>
The same functionality as then, but wraps the result in only one function
let r = asynchronous::Promise::new(|| {
if false { Ok(1.23) } else { Err("Final error")}
}).chain(|res| {
// Do something that executes always even on error
assert!(res.is_err());
res
}).then(|res| {
unreachable!();
assert_eq!(res, 1.23);
Ok(34)
}, |err| {
assert_eq!(err, "Final error");
if true { Ok(35) } else { Err(44u64)}
}).sync();
assert_eq!(r, Ok(35));
Sourcepub fn success<TT, F>(self, f: F) -> Promise<TT, E>
pub fn success<TT, F>(self, f: F) -> Promise<TT, E>
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)
}).success(|res| {
assert_eq!(res, 1.23);
Ok(34)
}).success(|res| {
assert_eq!(res, 34);
if true { Ok(res) } else { Err("Final error")}
}).sync();
Sourcepub fn fail<F>(self, f: F) -> Promise<T, E>
pub fn fail<F>(self, f: F) -> Promise<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)
}).success(|res| {
unreachable!();
Ok(res)
}).fail(|err| {
assert_eq!(err, 32);
Ok("Value Ok")
}).sync();
Sourcepub fn finally<F>(self, f: F)
pub fn finally<F>(self, f: F)
Executes one function with the result of the previous promise. 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.unwrap(), 32);
});
let a = 2 + 3; // This line is executed before the above Promise
Sourcepub fn finally_sync<F>(self, f: F)
pub fn finally_sync<F>(self, f: F)
Executes one function with the result of the previous promise. 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.unwrap(), 32);
});
let a = 2 + 3; // This line is executed after the above Promise