Handler trait

#[diagnostic::on_unimplemented(
    note = "Consider using `#[axum::debug_handler]` to improve the error message"
)]
pub trait Handler<T, S>: Clone + Send + Sync + Sized + 'static {
    /// The type of future calling this handler returns.
    type Future: Future<Output = Response> + Send + 'static;

    /// Call the handler with the given request.
    fn call(self, req: Request, state: S) -> Self::Future;

    fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
    // ...

    fn with_state(self, state: S) -> HandlerService<Self, T, S>
    // ...
}

/// The type parameter `T` is a workaround for trait coherence rules, allowing us to
/// write blanket implementations of `Handler` over many types of handler functions
/// with different numbers of arguments, without the compiler forbidding us from doing
/// so because one type `F` can in theory implement both `Fn(A) -> X` and `Fn(A, B) -> Y`.
/// `T` is a placeholder taking on a representation of the parameters of the handler function,
/// as well as other similar 'coherence rule workaround' discriminators,
/// allowing us to select one function signature to use as a `Handler`.

trait Handler {
  fn call(self) -> String;
}

impl<F, A> Handler for F
where
  F: FnOnce(A) -> String,
  A: Default,
{
  fn call(self) -> String {
    self(A::default())
  }
}

fn main() {}

error[E0207]: the type parameter `A` is not constrained by the impl trait, self type, or predicates
 --> src/bin/marker_missing.rs:5:9
  |
5 | impl<F, A> Handler for F
  |         ^ unconstrained type parameter

trait Handler<T> {
  fn call(self) -> String;
}

impl<F, A> Handler<(A,)> for F
where
  F: FnOnce(A) -> String,
  A: Default,
{
  fn call(self) -> String {
    self(A::default())
  }
}

impl<F, A, B> Handler<(A, B)> for F
where
  F: FnOnce(A, B) -> String,
  A: Default,
  B: Default,
{
  fn call(self) -> String {
    self(A::default(), B::default())
  }
}

fn run<T, H: Handler<T>>(h: H) -> String {
  h.call()
}

fn one(n: u8) -> String {
  format!("one({n})")
}

fn two(s: String, b: bool) -> String {
  format!("two({s:?}, {b})")
}

fn main() {
  println!("{}", run(one));
  println!("{}", run(two));
}

one(0)
two("", false)

macro_rules! impl_handler {
    (
        [$($ty:ident),*], $last:ident
    ) => {
        #[diagnostic::do_not_recommend]
        #[allow(non_snake_case, unused_mut)]
        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,
        {
            type Future = Pin<Box<dyn Future<Output = Response> + Send>>;

            fn call(self, req: Request, state: S) -> Self::Future {
                let (mut parts, body) = req.into_parts();
                Box::pin(async move {
                    $(
                        let $ty = match $ty::from_request_parts(&mut parts, &state).await {
                            Ok(value) => value,
                            Err(rejection) => return rejection.into_response(),
                        };
                    )*

                    let req = Request::from_parts(parts, body);

                    let $last = match $last::from_request(req, &state).await {
                        Ok(value) => value,
                        Err(rejection) => return rejection.into_response(),
                    };

                    self($($ty,)* $last,).await.into_response()
                })
            }
        }
    };
}

all_the_tuples!(impl_handler);

macro_rules! all_the_tuples {
    ($name:ident) => {
        $name!([], T1);
        $name!([T1], T2);
        $name!([T1, T2], T3);
        // ...
        $name!([T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], T16);
    };
}

    #[diagnostic::do_not_recommend]
    #[allow(non_snake_case, unused_mut)]
    impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
    where
        F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,
        Fut: Future<Output = Res> + Send,
        S: Send + Sync + 'static,
        Res: IntoResponse,
        T1: FromRequestParts<S> + Send,
        T2: FromRequest<S, M> + Send,
    {
        type Future = Pin<Box<dyn Future<Output = Response> + Send>>;
        fn call(self, req: Request, state: S) -> Self::Future {
            let (mut parts, body) = req.into_parts();
            Box::pin(async move {
                let T1 = match T1::from_request_parts(&mut parts, &state).await {
                    Ok(value) => value,
                    Err(rejection) => return rejection.into_response(),
                };
                let req = Request::from_parts(parts, body);
                let T2 = match T2::from_request(req, &state).await {
                    Ok(value) => value,
                    Err(rejection) => return rejection.into_response(),
                };
                self(T1, T2).await.into_response()
            })
        }
    }

axum = { version = "=0.8.9", default-features = false }

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

type M = Method;

async fn sixteen(
  _: M, _: M, _: M, _: M, _: M, _: M, _: M, _: M,
  _: M, _: M, _: M, _: M, _: M, _: M, _: M, _: M,
) {}

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

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

error[E0277]: the trait bound `fn(Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method) -> _ {seventeen}: Handler<_, _>` is not satisfied
   --> src/bin/seventeen.rs:18:23
    |
 18 |     .route("/17", get(seventeen));
    |                   --- ^^^^^^^^^ unsatisfied trait bound
    |                   |
    |                   required by a bound introduced by this call
    |
    = help: the trait `Handler<_, _>` is not implemented for fn item `fn(Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method, Method) -> _ {seventeen}`
    = note: Consider using `#[axum::debug_handler]` to improve the error message
note: required by a bound in `axum::routing::get`
   --> axum-0.8.9/src/routing/method_routing.rs:167:16
    |
167 |             H: Handler<T, S>,
    |                ^^^^^^^^^^^^^ required by this bound in `get`
...
441 | top_level_handler_fn!(get, GET);
    | -------------------------------
    | |                     |
    | |                     required by a bound in this function
    | in this macro invocation

impl<T, S> Handler<private::IntoResponseHandler, S> for T
where
    T: IntoResponse + Clone + Send + Sync + 'static,
{
    type Future = std::future::Ready<Response>;

    fn call(self, _req: Request, _state: S) -> Self::Future {
        std::future::ready(self.into_response())
    }
}

    fn call(self, req: Request, state: S) -> Self::Future {
        use futures_util::future::{FutureExt, Map};

        let svc = self.handler.with_state(state);
        let svc = self.layer.layer(svc);

        let future: Map<
            _,
            fn(
                Result<
                    <L::Service as Service<Request>>::Response,
                    <L::Service as Service<Request>>::Error,
                >,
            ) -> _,
        > = svc.oneshot(req).map(|result| match result {
            Ok(res) => res.into_response(),
            Err(err) => match err {},
        });

        future::LayeredFuture::new(future)
    }

impl<H, T, S, B> Service<Request<B>> for HandlerService<H, T, S>
where
    H: Handler<T, S> + Clone + Send + 'static,
    B: HttpBody<Data = Bytes> + Send + 'static,
    B::Error: Into<BoxError>,
    S: Clone + Send + Sync,
{
    type Response = Response;
    type Error = Infallible;
    type Future = super::future::IntoServiceFuture<H::Future>;

    #[inline]
    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        // `IntoService` can only be constructed from async functions which are always ready, or
        // from `Layered` which buffers in `<Layered as Handler>::call` and is therefore
        // also always ready.
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: Request<B>) -> Self::Future {
        use futures_util::future::FutureExt;

        let req = req.map(Body::new);

        let handler = self.handler.clone();
        let future = Handler::call(handler, req, self.state.clone());
        let future = future.map(Ok as _);

        super::future::IntoServiceFuture::new(future)
    }
}

request with x-token = true
  Step<1>  trail = [1]
  Guard     x-token present = true
  Step<2>  trail = [1, 2]
  Text      trail = Some([1, 2]), body = "hi"
  handler   body = "hi"
  -> 200 OK b"got hi"
request with x-token = false
  Step<1>  trail = [1]
  Guard     x-token present = false
  -> 401 Unauthorized b"missing x-token"