the trait bound fn(...) {handler}: Handler<_, _> is not satisfied

        impl<F, Fut, S, Res, M, $($ty,)* $last> Handler<(M, $($ty,)* $last,), S> for F
        where
            F: FnOnce($($ty,)* $last,) -> Fut + Clone + Send + Sync + 'static,
            Fut: Future<Output = Res> + Send,
            S: Send + Sync + 'static,
            Res: IntoResponse,
            $( $ty: FromRequestParts<S> + Send, )*
            $last: FromRequest<S, M> + Send,

axum = { version = "=0.8.9", features = ["macros"] }
serde = { version = "1", features = ["derive"] }

use std::sync::{Arc, Mutex};

use axum::{Router, extract::State, routing::post};

#[derive(Clone, Default)]
struct AppState {
  hits: Arc<Mutex<u64>>,
}

async fn audit(n: u64) {
  let _ = n;
}

async fn hit(State(state): State<AppState>) -> String {
  let mut hits = state.hits.lock().unwrap();
  *hits += 1;
  audit(*hits).await;
  format!("hits = {hits}")
}

fn main() {
  let _app: Router = Router::new()
    .route("/hit", post(hit))
    .with_state(AppState::default());
}

error[E0277]: the trait bound `fn(State<AppState>) -> impl Future<Output = String> {hit}: Handler<_, _>` is not satisfied
   --> src/bin/send.rs:23:25
    |
 23 |     .route("/hit", post(hit))
    |                    ---- ^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(State<AppState>) -> impl Future<Output = String> {hit}`
    |                    |
    |                    required by a bound introduced by this call
    |
    = note: Consider using `#[axum::debug_handler]` to improve the error message
note: required by a bound in `post`
   --> axum-0.8.9/src/routing/method_routing.rs:167:16
    |
167 |             H: Handler<T, S>,
    |                ^^^^^^^^^^^^^ required by this bound in `post`
...
445 | top_level_handler_fn!(post, POST);
    | ---------------------------------
    | |                     |
    | |                     required by a bound in this function
    | in this macro invocation
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

error: future cannot be sent between threads safely
  --> src/bin/send_dbg.rs:14:1
   |
14 | #[axum::debug_handler]
   | ^^^^^^^^^^^^^^^^^^^^^^ future returned by `hit` is not `Send`
   |
   = help: within `impl Future<Output = String>`, the trait `Send` is not implemented for `std::sync::MutexGuard<'_, u64>`
note: future is not `Send` as this value is used across an await
  --> src/bin/send_dbg.rs:18:16
   |
16 |   let mut hits = state.hits.lock().unwrap();
   |       -------- has type `std::sync::MutexGuard<'_, u64>` which is not `Send`
17 |   *hits += 1;
18 |   audit(*hits).await;
   |                ^^^^^ await occurs here, with `mut hits` maybe used later
note: required by a bound in `__axum_macros_check_hit_future::check`
  --> src/bin/send_dbg.rs:14:1
   |
14 | #[axum::debug_handler]
   | ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
   = note: this error originates in the attribute macro `axum::debug_handler` (in Nightly builds, run with -Z macro-backtrace for more info)

use std::rc::Rc;

use axum::{Router, routing::get};

async fn load() -> u32 {
  7
}

#[axum::debug_handler]
async fn page() -> String {
  let title = Rc::new(String::from("home"));
  let n = load().await;
  format!("{title}: {n}")
}

fn main() {
  let _app: Router = Router::new().route("/", get(page));
}

error: future cannot be sent between threads safely
  --> src/bin/send_rc_dbg.rs:9:1
   |
 9 | #[axum::debug_handler]
   | ^^^^^^^^^^^^^^^^^^^^^^ future returned by `page` is not `Send`
   |
   = help: within `impl Future<Output = String>`, the trait `Send` is not implemented for `Rc<String>`
note: future is not `Send` as this value is used across an await
  --> src/bin/send_rc_dbg.rs:12:18
   |
11 |   let title = Rc::new(String::from("home"));
   |       ----- has type `Rc<String>` which is not `Send`
12 |   let n = load().await;
   |                  ^^^^^ await occurs here, with `title` maybe used later

use axum::{Json, Router, http::HeaderMap, routing::post};
use serde::Deserialize;

#[derive(Deserialize)]
struct NewUser {
  name: String,
}

async fn create(Json(user): Json<NewUser>, headers: HeaderMap) -> String {
  format!("{} from {:?}", user.name, headers.get("user-agent"))
}

fn main() {
  let _app: Router = Router::new().route("/users", post(create));
}

error[E0277]: the trait bound `fn(Json<NewUser>, HeaderMap) -> impl Future<Output = String> {create}: Handler<_, _>` is not satisfied
   --> src/bin/order.rs:14:57
    |
 14 |   let _app: Router = Router::new().route("/users", post(create));
    |                                                    ---- ^^^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(Json<NewUser>, HeaderMap) -> impl Future<Output = String> {create}`

error: `Json<_>` consumes the request body and thus must be the last argument to the handler function
  --> src/bin/order_dbg.rs:10:29
   |
10 | async fn create(Json(user): Json<NewUser>, headers: HeaderMap) -> String {
   |                             ^^^^

use axum::{Router, http::HeaderMap, routing::get};

type H = HeaderMap;

async fn seventeen(
  _: H, _: H, _: H, _: H, _: H, _: H, _: H, _: H,
  _: H, _: H, _: H, _: H, _: H, _: H, _: H, _: H, _: H,
) {}

fn main() {
  let _app: Router = Router::new().route("/17", get(seventeen));
}

error[E0277]: the trait bound `fn(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _) -> _ {seventeen}: Handler<_, _>` is not satisfied
   --> src/bin/seventeen.rs:11:53
    |
 11 |   let _app: Router = Router::new().route("/17", get(seventeen));
    |                                                 --- ^^^^^^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _) -> _ {seventeen}`

error: Handlers cannot take more than 16 arguments. Use `(a, b): (ExtractorA, ExtractorA)` to further nest extractors
 --> src/bin/seventeen_dbg.rs:7:3
  |
7 | /   _: H, _: H, _: H, _: H, _: H, _: H, _: H, _: H,
8 | |   _: H, _: H, _: H, _: H, _: H, _: H, _: H, _: H, _: H,
  | |_______________________________________________________^

use axum::{Router, extract::Path, routing::get};

#[derive(Debug)]
enum AppError {
  NotFound,
}

async fn user(Path(id): Path<u32>) -> Result<String, AppError> {
  if id == 0 {
    return Err(AppError::NotFound);
  }
  Ok(format!("user {id}"))
}

fn main() {
  let _app: Router = Router::new().route("/users/{id}", get(user));
}

error[E0277]: the trait bound `fn(Path<u32>) -> impl Future<Output = _> {user}: Handler<_, _>` is not satisfied
   --> src/bin/ret.rs:16:61
    |
 16 |   let _app: Router = Router::new().route("/users/{id}", get(user));
    |                                                         --- ^^^^ unsatisfied trait bound
    |                                                         |
    |                                                         required by a bound introduced by this call
    |
    = help: the trait `Handler<_, _>` is not implemented for fn item `fn(axum::extract::Path<u32>) -> impl Future<Output = Result<String, AppError>> {user}`

error[E0277]: the trait bound `AppError: IntoResponse` is not satisfied
 --> src/bin/ret_dbg.rs:9:39
  |
9 | async fn user(Path(id): Path<u32>) -> Result<String, AppError> {
  |                                       ^^^^^^ unsatisfied trait bound
  |
help: the trait `IntoResponse` is not implemented for `AppError`
 --> src/bin/ret_dbg.rs:4:1
  |
4 | enum AppError {
  | ^^^^^^^^^^^^^
  = help: the following other types implement trait `IntoResponse`:
            ()
            (R,)
            (Response<()>, R)
            (StatusCode, R)
            (T1, R)
            (axum::http::response::Parts, R)
            (Response<()>, T1, R)
            (StatusCode, T1, R)
          and 132 others
  = note: required for `Result<String, AppError>` to implement `IntoResponse`
note: required by a bound in `__axum_macros_check_user_into_response::{closure#0}::check`
 --> src/bin/ret_dbg.rs:9:39
  |
9 | async fn user(Path(id): Path<u32>) -> Result<String, AppError> {
  |                                       ^^^^^^ required by this bound in `check`

use axum::{Json, Router, routing::post};

struct NewUser {
  name: String,
}

async fn create(Json(user): Json<NewUser>) -> String {
  format!("created {}", user.name)
}

fn main() {
  let _app: Router = Router::new().route("/users", post(create));
}

error[E0277]: the trait bound `fn(Json<NewUser>) -> impl Future<Output = String> {create}: Handler<_, _>` is not satisfied
   --> src/bin/extractor.rs:12:57
    |
 12 |   let _app: Router = Router::new().route("/users", post(create));
    |                                                    ---- ^^^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(Json<NewUser>) -> impl Future<Output = String> {create}`

error[E0277]: the trait bound `NewUser: serde::Deserialize<'de>` is not satisfied
 --> src/bin/extractor_dbg.rs:8:29
  |
8 | async fn create(Json(user): Json<NewUser>) -> String {
  |                             ^^^^ unsatisfied trait bound
  |
help: the trait `for<'de> serde_core::de::Deserialize<'de>` is not implemented for `NewUser`
 --> src/bin/extractor_dbg.rs:3:1
  |
3 | struct NewUser {
  | ^^^^^^^^^^^^^^
  = note: for local types consider adding `#[derive(serde::Deserialize)]` to your `NewUser` type
  = note: for types from other crates check whether the crate offers a `serde` feature flag
  = help: the following other types implement trait `serde_core::de::Deserialize<'de>`:
            &'a [u8]
            &'a serde_json::raw::RawValue
            &'a std::path::Path
            &'a str
            ()
            (T,)
            (T0, T1)
            (T0, T1, T2)
          and 143 others
  = note: required for `NewUser` to implement `serde_core::de::DeserializeOwned`
  = note: required for `Json<NewUser>` to implement `FromRequest<()>`

error[E0277]: the trait bound `NewUser: FromRequest<(), axum_core::extract::private::ViaParts>` is not satisfied
  --> src/bin/bare_dbg.rs:10:23
   |
10 | async fn create(user: NewUser) -> String {
   |                       ^^^^^^^ unsatisfied trait bound
   |
help: the trait `FromRequestParts<()>` is not implemented for `NewUser`
  --> src/bin/bare_dbg.rs:5:1
   |
 5 | struct NewUser {
   | ^^^^^^^^^^^^^^
   = note: Function argument is not a valid axum extractor. 
           See `https://docs.rs/axum/0.8/axum/extract/index.html` for details
   = help: the following other types implement trait `FromRequestParts<S>`:
             `ConnectInfo<T>` implements `FromRequestParts<S>`
             `Extension<T>` implements `FromRequestParts<S>`
             `HeaderMap` implements `FromRequestParts<S>`
             `MatchedPath` implements `FromRequestParts<S>`
             `Method` implements `FromRequestParts<S>`
             `OriginalUri` implements `FromRequestParts<S>`
             `Query<T>` implements `FromRequestParts<S>`
             `RawPathParams` implements `FromRequestParts<S>`
           and 7 others
   = note: required for `NewUser` to implement `FromRequest<(), axum_core::extract::private::ViaParts>`

    quote! {
        #item_fn
        #check_extractor_count
        #check_path_extractor
        #check_output_impls_into_response
        #check_inputs_and_future_send
        #middleware_takes_next_as_last_arg
    }

axum = "=0.8.9"
serde = { version = "1", features = ["derive"] }
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread"] }
tower = { version = "=0.5.3", features = ["util"] }
http-body-util = "0.1"

use std::sync::{Arc, Mutex};

use axum::{
  Json, Router,
  body::Body,
  extract::{Path, State},
  http::{HeaderMap, Request, StatusCode},
  response::{IntoResponse, Response},
  routing::{get, post},
};
use http_body_util::BodyExt;
use serde::Deserialize;
use tower::ServiceExt;

#[derive(Clone, Default)]
struct AppState {
  hits: Arc<Mutex<u64>>,
}

async fn audit(n: u64) {
  let _ = n;
}

// 1. the guard lives in a block that ends before `.await`
async fn hit(State(state): State<AppState>) -> String {
  let n = {
    let mut hits = state.hits.lock().unwrap();
    *hits += 1;
    *hits
  };
  audit(n).await;
  format!("hits = {n}")
}

#[derive(Deserialize)]
struct NewUser {
  name: String,
}

// 2. the body extractor moves to the end; 5. NewUser derives Deserialize
async fn create(headers: HeaderMap, Json(user): Json<NewUser>) -> String {
  format!("{} from {:?}", user.name, headers.get("user-agent"))
}

// 3. seventeen extractors, packed into one tuple argument
type H = HeaderMap;

async fn seventeen(
  _: H, _: H, _: H, _: H, _: H, _: H, _: H, _: H,
  _: H, _: H, _: H, _: H, _: H, _: H, _: H, (_, _): (H, H),
) -> &'static str {
  "17 extractors"
}

// 4. the error type implements IntoResponse
#[derive(Debug)]
enum AppError {
  NotFound,
}

impl IntoResponse for AppError {
  fn into_response(self) -> Response {
    match self {
      AppError::NotFound => (StatusCode::NOT_FOUND, "no such user").into_response(),
    }
  }
}

async fn user(Path(id): Path<u32>) -> Result<String, AppError> {
  if id == 0 {
    return Err(AppError::NotFound);
  }
  Ok(format!("user {id}"))
}

#[tokio::main]
async fn main() {
  let app: Router = Router::new()
    .route("/hit", post(hit))
    .route("/users", post(create))
    .route("/17", get(seventeen))
    .route("/users/{id}", get(user))
    .with_state(AppState::default());

  let reqs = [
    Request::post("/hit").body(Body::empty()).unwrap(),
    Request::post("/hit").body(Body::empty()).unwrap(),
    Request::post("/users")
      .header("content-type", "application/json")
      .header("user-agent", "curl/8")
      .body(Body::from(r#"{"name":"ann"}"#))
      .unwrap(),
    Request::get("/17").body(Body::empty()).unwrap(),
    Request::get("/users/7").body(Body::empty()).unwrap(),
    Request::get("/users/0").body(Body::empty()).unwrap(),
  ];
  for req in reqs {
    let line = format!("{} {}", req.method(), req.uri());
    let res = app.clone().oneshot(req).await.unwrap();
    let status = res.status();
    let body = res.into_body().collect().await.unwrap().to_bytes();
    println!("{line:<16} {status} {}", String::from_utf8_lossy(&body));
  }
}

POST /hit        200 OK hits = 1
POST /hit        200 OK hits = 2
POST /users      200 OK ann from Some("curl/8")
GET /17          200 OK 17 extractors
GET /users/7     200 OK user 7
GET /users/0     404 Not Found no such user