Why is the Send trait required inside my match block?

Question

I think my question relates to Rust Issue 57017.

The following code does not compile and produces error: future cannot be sent between threads safely due to future created by async block is not 'Send' originating in async fn execute_fail. On the other hand async fn execute_work compiles and has the same functions and logic as execute_fail but in a less elegant manner.

async fn stream() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
}

async fn process() {}

async fn execute_fail() -> Result<(), Box<dyn std::error::Error>> {
    match stream().await {
        Err(err) => {
            return Err(err);
        }
        Ok(()) => {
            process().await;
        }
    }
    Ok(())
}

async fn execute_work() -> Result<(), Box<dyn std::error::Error>> {
    let mut is_success = false;
    match stream().await {
        Err(err) => {
            return Err(err);
        }
        Ok(()) => {
            is_success = true;
        }
    }

    if is_success {
        process().await;
    }
    Ok(())
}

async fn my_fn() {
    tokio::spawn(async {
        if let Err(err) = execute_fail().await {
            panic!("error here");
        }
    });

    tokio::spawn(async {
        if let Err(err) = execute_work().await {
            panic!("error here");
        }
    });
}

Gives:

error: future cannot be sent between threads safely
   --> src/lib.rs:39:5
    |
39  |     tokio::spawn(async {
    |     ^^^^^^^^^^^^ future created by async block is not `Send`
    | 
   ::: /playground/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.11.0/src/task/spawn.rs:127:21
    |
127 |         T: Future + Send + 'static,
    |                     ---- required by this bound in `tokio::spawn`
    |
    = help: the trait `Send` is not implemented for `dyn std::error::Error`
note: future is not `Send` as this value is used across an await
   --> src/lib.rs:15:13
    |
10  |     match stream().await {
    |           -------------- has type `Result<(), Box<dyn std::error::Error>>` which is not `Send`
...
15  |             process().await;
    |             ^^^^^^^^^^^^^^^ await occurs here, with `stream().await` maybe used later
16  |         }
17  |     }
    |     - `stream().await` is later dropped here

I would like an explanation why execute_fail does not compile where as execute_work does. The compiler note note: future is not Send as this value is used across an await doesn't make sense to me as I don't see how any values are being used across an await.

`stream().await` is considered to be in use until the closing brace of the `match`, but you call `process().await` inside the `match` — Jmb, Sep 30 '21 at 12:18
Do you know why the compiler thinks that? I can understand the result of `stream().await` being inside `match` but not the actual future which should be resolved by the time the result is processed within the `match` clause. — Dan, Sep 30 '21 at 12:24
The `stream().await` future is indeed resolved by the time `match` is actually processes. The problem is it overlaps `process().await`, and types must be `Send` to live "through" an `await`. Which `Result<(), Box>` is not because `Box` is not. — Masklinn, Sep 30 '21 at 12:27
The problem is not `stream().await`, if you replace `stream()` by a non-async function you'll get the same error. The problem is that the lifetime of the `Result` (which is non-send) overlaps with `process().await`. Because a future can be resumed on a different scheduler (and thus thread) than it was suspended, values overlapping with an `await` call must be `Send`. — Masklinn, Sep 30 '21 at 12:34

Masklinn · Accepted Answer · 2021-10-01T05:53:09.837

I would like an explanation why execute_fail does not compile where as execute_work does.

When you match stream().await it essentially works as:

let v = stream().await;
match v {
   ...
}

So v is alive for the entirety of the match, meaning as far as the compiler is concerned its "life" overlaps with the process().await call. Values must be Send to live through an await call, as the coroutine may be resumed on a different thread than it was suspended.

Of note: the code here can be significantly simplified:

async fn execute_fail() -> Result<(), Box<dyn std::error::Error>> {
    if let Err(err) = stream().await {
        return Err(err);
    }
    process().await;
    Ok(())
}

or even

async fn execute_fail() -> Result<(), Box<dyn std::error::Error>> {
    stream().await?;
    process().await;
    Ok(())
}

Why is the Send trait required inside my match block?

1 Answers1

Linked