Generic route handler with #[get] macro?

[JakubKoralewski]

I am writing handlers with the #[get] macro and wanted to make the function generic, I've got some compiler error, so I started writing something like this:

#[allow(non_camel_case_types, missing_docs)]
pub struct request_token<CB: CBTrait>(CBG<CB>);
impl<CB: CBTrait> request_token<CB> {
    pub fn new() -> Self {
        Self(PhantomData::<CBGInner<CB>>)
    }
}
impl<CB: CBTrait> actix_web::dev::HttpServiceFactory for request_token<CB> {
    fn register(self, __config: &mut actix_web::dev::AppService) {
        let request_token_res =
            actix_web::Resource::new("/oauth/{x}/request_token")
                .name("request_token")
                .guard(actix_web::guard::Get())
                .to(request_token_fn::<CB>);
        actix_web::dev::HttpServiceFactory::register(
            request_token_res,
            __config,
        );
    }
}

#[instrument(skip(uni_data, client))]
pub async fn request_token_fn<CB: CBTrait>(
    x: web::Path<String>,
    client: web::Data<<CB as RequestBuildah>::ClientBuilder>,
) -> Result<impl Responder, MyError> {

I'm wondering if there's a less boilerplate-y way to write this, or maybe a macro? Or maybe the #[get] family of macros could be somehow modified to accept generic parameters?

[JakubKoralewski]

I wrote something like this:

#[macro_export]
macro_rules! count {
    () => (0usize);
    ( $x:tt $($xs:tt)* ) => (1usize + $crate::count!($($xs)*));
}

#[macro_export]
macro_rules! generalize_actix_handler {
    (method:$method:ident, fn: $fn_name:ident, struct_name: $struct_name:ident, path: $uri_path:literal, generics: <$($gen_param:ident: $gen_type:path),*>) => {
        #[allow(non_camel_case_types, missing_docs)]
        pub struct $struct_name<$($gen_param:$gen_type),*>([$(PhantomData<fn() -> $gen_param>),*; $crate::count!($($gen_param),*)]);
        impl<$($gen_param:$gen_type),*> $struct_name<$($gen_param),*> {
            pub fn new() -> Self {
                Self([$(PhantomData::<fn() -> $gen_param>),*; $crate::count!($($gen_param),*)])
            }
        }
        impl<$($gen_param:$gen_type),*> actix_web::dev::HttpServiceFactory for $struct_name<$($gen_param),*> {
            fn register(self, __config: &mut actix_web::dev::AppService) {
                let res =
                    actix_web::Resource::new($uri_path)
                        .name(stringify!($fn_name))
                        .guard(actix_web::guard::$method())
                        .to($fn_name::<$($gen_param),*>);
                actix_web::dev::HttpServiceFactory::register(
                    res,
                    __config,
                );
            }
        }
    }
}

Seems to work. Would be happy to know of other ways to do this.

[JakubKoralewski]

You can probably get away with a tuple instead of an array.

[JakubKoralewski]

#[macro_export]
macro_rules! generalize_actix_handler {
    (method:$method:ident, fn: $fn_name:ident, struct_name: $struct_name:ident, path: $uri_path:literal, generics: <$($gen_param:ident: $gen_type:path),*>) => {
        #[allow(non_camel_case_types, missing_docs)]
        pub struct $struct_name<$($gen_param:$gen_type),*>(($(PhantomData<fn() -> $gen_param>,)*));
        impl<$($gen_param:$gen_type),*> $struct_name<$($gen_param),*> {
            pub fn new() -> Self {
                Self(($(PhantomData::<fn() -> $gen_param>,)*))
            }
        }
        impl<$($gen_param:$gen_type),*> actix_web::dev::HttpServiceFactory for $struct_name<$($gen_param),*> {
            fn register(self, __config: &mut actix_web::dev::AppService) {
                let res =
                    actix_web::Resource::new($uri_path)
                        .name(stringify!($fn_name))
                        .guard(actix_web::guard::$method())
                        .to($fn_name::<$($gen_param),*>);
                actix_web::dev::HttpServiceFactory::register(
                    res,
                    __config,
                );
            }
        }
    }

Yup and the count macro can be removed.