thunks 0.1.0

Asynchronous composer for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

thunks
====
Asynchronous composer for Rust.

[![Crates version][version-image]][version-url]
[![Build Status][travis-image]][travis-url]
[![Coverage Status][coveralls-image]][coveralls-url]
[![Crates downloads][downloads-image]][downloads-url]

## Demo

**primitive thunk:**
```rust
let thunk: Thunk<i32, &str> = Thunk::new(|cb| {
    thread::spawn(move || {
        thread::sleep(Duration::new(3, 0));
        cb(Ok(1));
    });
});
let res = thunk.await().unwrap();
assert_eq!(res, 1);
```

**Sequence control:**
```rust
let thunk_vec: Vec<Thunk<i32, &str>> = vec![
    Thunk::new(|cb| {
        thread::spawn(move || {
            thread::sleep(Duration::new(1, 0));
            cb(Ok(1));
        });
    }),
    Thunk::new(|cb| {
        thread::spawn(move || {
            thread::sleep(Duration::new(1, 0));
            cb(Ok(2));
        });
    }),
    Thunk::new(|cb| {
        thread::spawn(move || {
            thread::sleep(Duration::new(1, 0));
            cb(Ok(3));
        });
    })
];
let res = Thunk::seq(thunk_vec).await().unwrap();
assert_eq!(res, vec![1, 2, 3]);
```

**Parallel control:**
```rust
let thunk_vec: Vec<Thunk<i32, &str>> = vec![
    Thunk::new(|cb| {
        thread::spawn(move || {
            thread::sleep(Duration::new(1, 0));
            cb(Ok(1));
        });
    }),
    Thunk::new(|cb| {
        thread::spawn(move || {
            thread::sleep(Duration::new(1, 0));
            cb(Ok(2));
        });
    }),
    Thunk::new(|cb| {
        thread::spawn(move || {
            thread::sleep(Duration::new(1, 0));
            cb(Ok(3));
        });
    })
];
let res = Thunk::all(thunk_vec).await().unwrap();
assert_eq!(res, vec![1, 2, 3]);
```

## JavaScript Version: https://github.com/thunks/thunks

## API
### Documentation https://iorust.github.io/thunks/thunks

```rust
extern crate thunks;
use thunks::Thunk;
```

### Struct thunks::Thunk
```rust
pub struct Thunk<T, E>(_)
```

### Methods
#### `impl<T, E> Thunk<T, E> where T: Send + 'static, E: Send + 'static`

```rust
fn new<F>(task: F) -> Thunk<T, E>
where F: Fn(Box<Fn(Result<T, E>) + Send + 'static>) + Send + 'static
```

```rust
fn seq(thunk_vec: Vec<Thunk<T, E>>) -> Thunk<Vec<T>, E>
```

```rust
fn all(thunk_vec: Vec<Thunk<T, E>>) -> Thunk<Vec<T>, E>
```

```rust
fn await(&self) -> Result<T, E>
```

[version-image]: https://img.shields.io/crates/v/thunks.svg
[version-url]: https://crates.io/crates/thunks

[travis-image]: http://img.shields.io/travis/iorust/thunks.svg
[travis-url]: https://travis-ci.org/iorust/thunks

[coveralls-image]: https://coveralls.io/repos/github/iorust/thunks/badge.svg?branch=master
[coveralls-url]: https://coveralls.io/github/iorust/thunks?branch=master

[downloads-image]: https://img.shields.io/crates/d/thunks.svg
[downloads-url]: https://crates.io/crates/thunks