13 个不稳定版本 (3 个破坏性更新)
使用旧的 Rust 2015
0.4.5 | 2015 年 5 月 22 日 |
---|---|
0.4.4 | 2015 年 5 月 18 日 |
0.3.3 | 2015 年 5 月 7 日 |
0.2.0 | 2015 年 5 月 5 日 |
0.1.1 | 2015 年 5 月 4 日 |
2012 在 异步 中
每月 下载 65 次
在 8 个 crate 中使用 (通过 json_rpc)
45KB
519 行
异步
使用线程在 Rust 中实现异步承诺
Crate | Travis |
---|---|
| API 文档 |
#概述
此库提供了一种使用分离线程以 承诺风格 调用函数(闭包)的有用方法。承诺是一个表示函数产生的返回值或错误的 Struct。
它还允许以延迟方式并行或串行执行任务,并在承诺中合并结果。
它包括管理事件循环的方法,其中存在在后台“发射”事件的任务,并由承诺收集。
该项目基于 Node JS 的 Q Promise 库和 Async.js
#许可证
双重许可,与 Rust 项目兼容。
根据您的选择,许可协议为 Apache 许可证第 2 版 https://apache.ac.cn/licenses/LICENSE-2.0 或 MIT 许可证 http://opensource.org/licenses/MIT。此文件不得根据这些条款复制、修改或分发。
示例
这是一个基于承诺执行的简单设置
use asynchronous::Promise;
Promise::new(|| {
// Do something
let ret = 10.0 / 3.0;
if ret > 0.0 { Ok(ret) } else { Err("Incorrect Value") }
}).success(|res| { // res has type f64
// Do something if the previous result is correct
assert_eq!(res, 10.0 / 3.0);
let res_int = res as u32 * 2;
Ok(res_int)
}).finally_sync(|res| { // res has type Result<u32,&str>
// Executed always at the end
assert_eq!(res.unwrap(), 6u32);
});
延迟执行
use asynchronous::{Promise,Deferred,ControlFlow};
let d_a = Deferred::<&str, &str>::new(|| { Ok("a") });
let p_b = Promise::<&str, &str>::new(|| { Ok("b") }); // Executed right now
let d1 = Deferred::<u32, &str>::new(|| { Ok(1u32) });
let d2 = Deferred::<u32, &str>::new(|| { Err("Mock Error") });
let d3 = Deferred::<u32, &str>::new(|| { Ok(3u32) });
let d4 = Deferred::<u32, &str>::new(|| { Ok(4u32) });
let d5 = Deferred::<u32, &str>::new(|| { Ok(5u32) });
let promise = Deferred::vec_to_promise(vec![d1,d2,d3], ControlFlow::Parallel);
// Only d1, d2 and d3 are being executed at this time.
assert_eq!("ab", d_a.to_promise().success(|res_a| {
p_b.success(move |res_b| {
Ok(res_a.to_string() + res_b)
}).sync()
}).sync().unwrap());
promise.success(|res| {
// Catch the result. In this case, tasks d4 and d5 never will be executed
Ok(res)
}).fail(|error| {
// Catch the error and execute another Promise
assert_eq!(error, vec![Ok(1u32), Err("Mock Error"), Ok(3u32)]);
Deferred::vec_to_promise(vec![d4,d5], ControlFlow::Series).sync()
}).finally_sync(|res| { // res : Result<Vec<u32>,&str>
// Do something here
assert_eq!(res.unwrap(), vec![4u32, 5u32]);
});
简单事件循环
use asynchronous::EventLoop;
let el = EventLoop::new().finish_in_ms(100);
el.emit("Event1");
el.emit("Event2");
// Do something here
el.to_promise().finally_sync(|res| { // res: Result<Vec<Ev>,()>
assert_eq!(res.unwrap(), vec!["Event1", "Event2"]);
});
依赖项
~77KB