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异步

Download history 14/week @ 2024-04-07 12/week @ 2024-04-14 17/week @ 2024-04-21 15/week @ 2024-04-28 16/week @ 2024-05-05 16/week @ 2024-05-12 19/week @ 2024-05-19 14/week @ 2024-05-26 15/week @ 2024-06-02 13/week @ 2024-06-09 10/week @ 2024-06-16 16/week @ 2024-06-23 33/week @ 2024-06-30 8/week @ 2024-07-07 12/week @ 2024-07-14 11/week @ 2024-07-21

每月 下载 65
8 个 crate 中使用 (通过 json_rpc)

Apache-2.0 / MIT

45KB
519

异步

使用线程在 Rust 中实现异步承诺

Crate Travis
Build Status

| API 文档 |

#概述

此库提供了一种使用分离线程以 承诺风格 调用函数(闭包)的有用方法。承诺是一个表示函数产生的返回值或错误的 Struct。

它还允许以延迟方式并行或串行执行任务,并在承诺中合并结果。

它包括管理事件循环的方法,其中存在在后台“发射”事件的任务,并由承诺收集。

项目 GitHub 页面

该项目基于 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