hiasync 0.1.4

# hiasync

一个单线程下调度异步任务的运行时, 不依赖任何底层系统接口，仅提供在同步环境下调用异步函数的能力.

## 版本说明

### v0.1.4
1. 新增`JoinHandle::abort`接口
2. 新增JoinSet, 管理多个并发的子异步任务. 参见`lib.rs`中的测试用例.

### v0.1.3

新增`partial_or`. 消除`or`中存在的异步任务可能被强制终止的场景.

### v0.1.2

新增`and`, `or`组合多个`Future`.

```rust
async fn foo() {
    // 收到任意一个消息后返回
    let (r1, r2) = wait_event::<Msg>(MSG_ID1).or(wait_event::<Msg>)(MSG_ID2)).await;
    if let Some(r1) = r1 {
        // 如果收到MsG_ID1
    }
    if let Some(r2) = r2 {
        // 如果收到MsG_ID2
    }
}
```

## 样例

主要应用于将非阻塞接口实现的同步函数改造为异步函数的场景.

如下是一个例子:
```rust
fn process_msg1(msg: Msg) {
    // ...
    nonblock_send_msg(new_request);
}

fn process_msg2(msg: Msg) {
    // ...
    nonblock_send_msg(new_request);
}

fn main() {
    while let Ok(msg) = recv_msg() {
        match msg.id {
            MSG_ID_1 => process_msg1(msg),
            MSG_ID_2 => process_msg2(msg),
            _ => //...
        }
    }
}

```

我们希望将`process_msg`改造为异步函数，可以如下实现:

```rust
use hiasync::{wait_event, Event, Runtime};

async fn process_msg1() {
    let msg = wait_event::<Msg>(MSG_ID_1).await;
    //...
    nonblock_send_msg(new_request);
}

async fn process_msg2() {
    let msg = wait_event::<Msg>(MSG_ID_2).await;
    //...
    nonblock_send_msg(new_request);
}

fn main() {
    let mut rt = Runtime::new();
    let _ = rt.spawn(process_msg1());
    let _ = rt.spawn(process_msg2());
    while let Ok(msg) = recv_msg() {
        rt.sched_events(&[Event::new(msg.id, &msg)]);
    }
}
```