Support for handler methods

[Kinrany]

Sometimes it makes sense to have a type that implements FromRequest and can be used to parse the whole request body. This is especially convenient with #[derive(FromRequest)] and #[from_request(via)].

For a request type like this it also makes a lot of sense for the handler function to be a method, callable as request.handle(...).

This currently doesn't work in the general case.

I believe one of the reasons Axum is loved this much is that it's not very frameworky. This is one of the few places where it creates and demands that users follow special Axum idioms instead of general Rust idioms.

In practice, I see two main obstacles:

1. self must be the first argument but FromRequest must be the last argument. This can be fixed cleanly by making FromRequest treat the first argument as special, but this would be a big breaking change of course.
2. #[axum::debug_handle] interprets self as module name.

A breaking change like this would be annoying and would certainly require some kind of automated rewriting. But feels definitely worth it in the long term?

[jplatte]

Can you show a real-world example? If you have a request type that's only meant to support a single route and uses #[derive(FromRequest)], why are there any arguments to the handle function other than self?

[Kinrany]

I usually find that I don't want to combine the capabilities provided by the context and the (parsed) request payload in the same type. It makes sense to pass the request payload around as plain data. Including references to other things feels like a you-wanted-a-banana-but-got-the-gorilla-holding-the-banana-and-the-whole-jungle kind of mistake. Not because it might cause memory leaks (probably not) but because the API ends up being less simple than it could be.

[Kinrany]

Another angle: I think one would almost always want a smaller request type (payload only), if only as part of the larger request type (capabilities included).

Once the smaller request type needs to exist anyway, it feels wrong to have to create the larger request type solely for the purpose of then implementing the handler as a method on that type. For roughly the same reasons why it feels wrong to have to create a separate handler function that must be a dumb wrapper around real logic. It's boilerplate, and Rust is really good at eliminating boilerplate with traits and macros.