"what is the difference between `then`, `and_then` and `or_else` in rust futures?" Code Answer

tl;dr: then is used when you want to do something regardless of if the future was successful or not, and_then runs the closure only when the future succeeded, and or_else runs the closure only when the future failed.

and_then and or_else are direct analogs to the methods of the same name on result .

your first step should be to read the docs. the documentation contains the exact method signatures (which explain what types it expects and what the return types are), prose describing each method, and example usage as well.

i've extracted small snippets of the docs and emphasized the relevant parts.

future::then:

this function can be used to ensure a computation runs regardless of the conclusion of the future. the closure provided will be yielded a result once the future is complete.

the returned value of the closure must implement the intofuture trait and can represent some more work to be done before the composed future is finished.

future::and_then:

this function can be used to chain two futures together and ensure that the final future isn't resolved until both have finished. the closure provided is yielded the successful result of this future and returns another value which can be converted into a future.

future::or_else

return a future that passes along this future's value if it succeeds, and otherwise passes the error to the closure f and waits for the future it returns.

the return type for all three methods is any type that can be converted into another future.

• then: no additional restrictions on the return type.
• and_then requires that the error type of the returned future match the starting future's error type.
• or_else requires that the success type of the returned future match the starting future's success type.

use futures::{future, future}; // 0.1.25

struct error;

fn download_from_server(server: u8) -> impl future<item = vec<u8>, error = error> {
    /* ... */
}

fn upload_to_server(data: vec<u8>) -> impl future<item = usize, error = error> {
    /* ... */
}

// uses `or_else` to do work on failure
fn download() -> impl future<item = vec<u8>, error = error> {
    download_from_server(0)
        .or_else(|_| download_from_server(1))
        .or_else(|_| download_from_server(2))
}

// uses `and_then` to do work on success
fn reupload() -> impl future<item = usize, error = error> {
    download().and_then(|data| upload_to_server(data))
}

// uses `then` to always do work
fn do_things() -> impl future<item = (), error = ()> {
    reupload().then(|r| {
        match r {
            ok(size) => println!("uploaded {} bytes", size),
            err(_) => println!("got an error"),
        };
        ok(())
    })
}

some cases are simplified by the async / await syntax stabilized in rust 1.39:

// equivalent to `or_else`
async fn download() -> result<vec<u8>, error> {
    match download_from_server(0).await {
        ok(v) => ok(v),
        err(_) => match download_from_server(1).await {
            ok(v) => ok(v),
            err(_) => download_from_server(2).await,
        },
    }
}

// equivalent to `and_then`
async fn reupload() -> result<usize, error> {
    let data = download().await?;
    upload_to_server(data).await
}

// equivalent to `then`
async fn do_things() -> result<(), ()> {
    match reupload().await {
        ok(size) => println!("uploaded {} bytes", size),
        err(_) => println!("got an error"),
    }
    ok(())
}