completable_future 0.2.0

CompletableFuture 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

# Completable Future

Similar to Java's CompletableFuture, this crate provides a simple
future that can be completed and properly notified from elsewhere other
than the executor of the future. It is sutable for some blocking
tasks that could block the executor if we use a future directly in
an executor.

A CompletableFuture is still a future and has all the combinators that
you can use to chain logic working on the result or the error. Also,
unlike Java and inherited from Rust's poll model future, some executor
needs to execute the CompletableFuture in order to get the result; the
thread or code that completes (or errors) the future will not execute
the logic chained after the future.

The CompletableFuture uses Arc and Mutex to synchronize poll and completion,
so there's overhead for using it.

# Example
```
extern crate futures;
extern crate completable_future;

use futures::prelude::*;
use futures::executor::block_on;
use std::thread::spawn;
use std::thread::sleep;
use std::time::Duration;

let fut1 = CompletableFuture::<String, ()>::new();
// we will give the signal to some worker for it to complete
let mut signal = fut1.signal(); 
let fut2 = fut1.and_then(|s| {
    // this will come from whoever completes the future
    println!("in fut2: {}", s);
    Ok("this comes from fut2".to_string())
});

let j = spawn(move || {
    println!("waiter thread: I'm going to block on fut2");
    let ret = block_on(fut2).unwrap();
    println!("waiter thread: fut2 completed with message -- {}", ret);
});

spawn(move || {
    println!("worker thread: going to block for 1000 ms");
    sleep(Duration::from_millis(1000));
    signal.complete("this comes from fut1".to_string());
    println!("worker thread: completed fut1");
});

j.join().unwrap();
```