Composable primitives for asynchronous computations

The async module contains utilities for managing asynchronous computations. These utilities are primarily based around Future and Stream types as well as functions that allow composing computations on these types.

Future

A Future is a proxy representing the result of a computation which may not be complete. The computation may be running concurrently in another thread or may be triggered upon completion of an asynchronous callback. One way to think of a Future is as a Result where the value is asynchronously computed.

For example:

use eventual::*;

// Run a computation in another thread
let future1 = Future::spawn(|| {
    // Represents an expensive computation, but for now just return a
    // number
    42
});

// Run another computation
let future2 = Future::spawn(|| {
    // Another expensive computation
    18
});

let res = join((
        future1.map(|v| v * 2),
        future2.map(|v| v + 5)))
    .and_then(|(v1, v2)| Ok(v1 - v2))
    .await().unwrap();

assert_eq!(61, res);

Stream

A Stream is like a Future, except that instead of representing a single value, it represents a sequence of values.

Eventual - Futures & Streams for Rust

Eventual provides a Future & Stream abstraction for Rust as well as a number of computation builders to operate on them.

• API documentation

Usage

To use Eventual, first add this to your Cargo.toml:

[dependencies.eventual]
git = "https://github.com/carllerche/eventual"

Then, add this to your crate root:

extern crate eventual;