Idea: Box services internally _and_ store the complete type

[davidpdrsn]

Note this branch currently includes #385. That makes the diff larger than it actually is.

All compile issues we've had comes from building very large types and rust not being very good at evaluating trait bounds on them. A common workaround is to use boxing to erase the types. People have suggested that axum internally box all routes. I've been reluctant to do that because I wanted to keep as much type information as possible so we could use it to do cool stuff, like generating OpenAPI specs purely based on the types.

Today I had an idea though, what if we both boxed all services and kept the type information? For example Route could be defined as:

pub struct Route<S, ReqBody, E, F> {
    // the route's path (this branch is using the pre matchit router)
    pub(crate) pattern: PathPattern,
    // the boxed service behind this route
    pub(crate) svc: CloneBoxService<Request<ReqBody>, Response<BoxBody>, E>,
    // keep the type of the original service so we can use it in trait bounds
    pub(crate) svc_ty: PhantomData<fn() -> S>,
    // the fallback route if this doesn't match
    pub(crate) fallback: F,
}

Service can then be implemented from these trait bounds:

impl<S, F, B, E> Service<Request<B>> for Route<S, B, E, F>
where
    F: Service<Request<B>, Response = Response<BoxBody>, Error = E> + Clone,
    B: Send + Sync + 'static,
{
    // ...
}

Notice here that there is no bounds on S. Thats because Route.svc is already a Service. No new bounds necessary.

Router::boxed can be defined like it used to be:

pub fn boxed<ReqBody, ResBody>(self) -> Router<BoxRoute<ReqBody, S::Error>>
where
    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone + Send + Sync + 'static,
    S::Error: Into<crate::BoxError> + Send,
    S::Future: Send,
    ReqBody: Send + 'static,
    ResBody: http_body::Body<Data = Bytes> + Send + Sync + 'static,
    ResBody::Error: Into<crate::BoxError>,
{
    self.layer(BoxRoute::<ReqBody, S::Error>::layer())
}

With these changes code like this:

let app: Router<BoxRoute> = Router::new()
    .route("/list", get(handle))
    .route("/home", get(handle))
    .route("/create", post(handle))
    .route("/update/:id", post(handle))
    .route("/delete", post(handle))
    .route("/detail", get(handle))
    .route("/earnings/create", post(handle))
    .route("/earnings/delete", post(handle))
    .route("/earnings/find", get(handle))
    .boxed();

compiles quickly. Previously it would take ages.

I think this approach is quite interesting and definitely something I'll look more into. Some todos

• Benchmark it
• Consider if this is really worth doing now it seems Fix compile time issues with Router::boxed #385 fixes issues with Router::boxed. Does this solve other problems that Fix compile time issues with Router::boxed #385 doesn't solve?
• Do a POC for OpenAPI generation and make sure its still possible from this setup.

[davidpdrsn]

Superseded by #401