How to implement a generic request guard?

[FoxLisk]

I want to set up a request handler that will only fire if the request has data that parses properly. This parsing is being done by a third party library that I do not control, and returns a generic struct.

With non-generic structs, I have had luck doing something like

struct ThingGuard(Thing);

and then implementing FromData and so on. This is really great.

However, although I can implement a ThingGuard<E>(Thing<E>), I can't actually use it in a route.

Example code:

#[macro_use] extern crate rocket;

use rocket::request::{FromRequest, Outcome};
use rocket::Request;

struct Generic<E> {
    e: E
}

struct GenericGuard<E> {
    e: Vec<E>
}

// stub for parsing input or whatever
fn make_a_thing<E>() -> Vec<E> {
    vec![]
}

#[rocket::async_trait]
impl<'r, E> FromRequest<'r> for GenericGuard<E> {
    type Error = ();

    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
        Outcome::Success(GenericGuard { e: make_a_thing::<E>()} )
    }
}


// This is where it goes wrong - the #[get] attribute appears to hate the generics here, or something?
#[get("/test")]
async fn guarded<E>(g: GenericGuard<E>) {

}

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![index])
}

The error I get is

error[E0412]: cannot find type `E` in this scope
   --> src\main.rs:28:37
    |
28  | async fn guarded<E>(g: GenericGuard<E>) {
    |                                     ^ help: a trait with a similar name exists: `Eq`
    | 
   ::: ...\lib/rustlib/src/rust\library\core\src\cmp.rs:272:1
    |
272 | pub trait Eq: PartialEq<Self> {
    | ----------------------------- similarly named trait `Eq` defined here

Is there a way to do this?

The obvious alternative is to create a request guard that doesn't store the parse results, thus getting around the requirement to have the generic struct that's causing the problem - then the request would be type safe (yay!) but would have to redo parsing work (boo).

A way for a request guard to communicate data without storing it like this would also probably solve my problem.

Thanks!

[the10thWiz]

At the moment, functions with the route attributes cannot have generics. This may be relaxed in the future, but even then only concrete routes can be mounted - so your mount would need to look something like .mount("/", routes![guarded::<ConcreteType>]). For now, I would recommend calling your generic function from routes with the actual types you want to allow.

[SergioBenitez]

See also #1570 for why this likely doesn't make sense.