Confusing middleware error message

[zookatron]

Consider the following snippet:

use axum::{
    http::Request,
    middleware::{self, Next},
    response::Redirect,
    Router,
};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    let app = Router::new().layer(middleware::from_fn(middleware));
    axum::Server::bind(&SocketAddr::from(([0, 0, 0, 0], 3000)))
        .serve(app.into_make_service())
        .await
        .unwrap();
}

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

async fn generate_response(x: &str) -> Redirect {
    Redirect::to(x)
}

async fn middleware<Data>(_request: Request<Data>, _next: Next<Data>) -> Redirect {
    match determine_a_or_b().await.unwrap_or(false) {
        true => generate_response("a").await,
        false => generate_response("b").await,
    }
}

If you try to compile this Rust gives you this very confusing error:

error[E0277]: the trait bound `axum::middleware::FromFn<fn(Request<_>, Next<_>) -> impl Future<Output = Redirect> {middleware::<_>}, (), Route<_>, _>: tower_service::Service<Request<_>>` is not satisfied
   --> src/main.rs:12:35
    |
12  |     let app = Router::new().layer(middleware::from_fn(middleware));
    |                             ----- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `tower_service::Service<Request<_>>` is not implemented for `axum::middleware::FromFn<fn(Request<_>, Next<_>) -> impl Future<Output = Redirect> {middleware::<_>}, (), Route<_>, _>`
    |                             |
    |                             required by a bound introduced by this call
    |
    = help: the following other types implement trait `tower_service::Service<Request>`:
              axum::middleware::FromFn<F, S, I, (T1, T2)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>
            and 8 others
note: required by a bound in `Router::<S, B>::layer`
   --> /app/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.6.18/src/routing/mod.rs:229:21
    |
229 |         L::Service: Service<Request<NewReqBody>> + Clone + Send + 'static,
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Router::<S, B>::layer`

After a lot of head scratching I figured out that if you explicitly specify the type parameters on the middleware::from_fn function like so:

#[tokio::main]
async fn main() {
    let app = Router::new().layer(middleware::from_fn::<_, (Request<hyper::body::Body>,)>(middleware));
    axum::Server::bind(&SocketAddr::from(([0, 0, 0, 0], 3000)))
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Rust will instead give you this much more understandable error:

error: future cannot be sent between threads safely
  --> src/main.rs:11:29
   |
11 |     let app = Router::new().layer(middleware::from_fn::<_, (Request<hyper::body::Body>,)>(middleware));
   |                             ^^^^^ future returned by `middleware` is not `Send`
   |
   = help: the trait `Send` is not implemented for `dyn std::error::Error`
   = help: the following other types implement trait `Service<Request>`:
             axum::middleware::FromFn<F, S, I, (T1, T2)>
             axum::middleware::FromFn<F, S, I, (T1, T2, T3)>
             axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4)>
             axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5)>
             axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6)>
             axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7)>
             axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)>
             axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>
           and 8 others
note: future is not `Send` as this value is used across an await
  --> src/main.rs:29:39
   |
28 |     match determine_a_or_b().await.unwrap_or(false) {
   |           ------------------------ has type `Result<bool, Box<dyn std::error::Error>>` which is not `Send`
29 |         true => generate_response("a").await,
   |                                       ^^^^^^ await occurs here, with `determine_a_or_b().await` maybe used later
...
32 | }
   | - `determine_a_or_b().await` is later dropped here

And it is clear that I can fix that just by adding a variable for the unwrapped value:

async fn middleware<Data>(_request: Request<Data>, _next: Next<Data>) -> Redirect {
    let a_or_b = determine_a_or_b().await.unwrap_or(false);
    match a_or_b {
        true => generate_response("a").await,
        false => generate_response("b").await,
    }
}

I'm trying to understand:
A) Why does adding the type parameter change the error message so dramatically?
B) Is this confusing initial error caused by a problem in Axum, one of its dependencies, or Rust itself? Is there anything that could be changed to avoid this problem?

[davidpdrsn]

It’s an issue in rust. Axum has the same issue for extractors. The problem is not unique to axum

[zookatron]

Thanks David, do you know of any documentation on why this kind of thing affects Rust's error messages in this way?

[davidpdrsn]

rust-lang/rust#89681