#[derive(FromParam)] for newtype structs

[RBerga06]

I sometimes use newtype structures to represent database identifiers (essentially to avoid mixing them up).

It would be very nice if I could write:

use rocket::{serde::json::Json, request::FromParam};
use serde::{Serialize, Deserialize}

#[derive(Serialize, Deserialize, FromParams)]
#[serde(transparent)]
struct BookId(usize);

#[rocket::get("/book/<id>")]
fn get_book(id: BookId) -> Json<Book> {
    // snip
}

but #[derive(FromParam)] only works (as documented) for C-like enums.
Would it make sense to also support #[derive(FromParam)] struct <name>(T); where T: FromForm?

Without it, I have to write something like:

use rocket::serde::json::Json;
use serde::{Serialize, Deserialize}

#[derive(Serialize, Deserialize)]
#[serde(transparent)]
struct BookId(usize);
impl BookId {
    pub fn from_raw(raw: usize) -> Self {
        Self(from_raw)
    }
}

#[rocket::get("/book/<id>")]
fn get(id: usize) -> Json<Book> {
	let id = BookId::from_raw(usize);
    // snip
}

(I cannot just use BookId(id) because I'd like to keep the constructor private - the struct actually lives in a different module).

The main drawback I can see is that I have to repeat usize (the inner/raw type) every time I want to use BookId. If, at some point, I decide that usize is not good enough for me and what I really need is uuid::Uuid, I have to update all HTTP methods that construct BookIds.

It's not a big deal, but I think that implementing automatically FromParam for newtype structs would make this kind of pattern more ergonomic and improve developer experience.

(P.S.: Sorry for my English, it's not my mother tongue)

(edit: typo)

[RBerga06]

I can of course always write a simple macro that implements FromParam for my types, something like:

/// Implement [`rocket::request::FromParam`] for the given newtype struct.
#[macro_export]
macro_rules! impl_FromParam_newtype {
    ($Struct:ident($Inner:ty)) => {
        impl<'r> rocket::request::FromParam<'r> for $Struct {
            type Error = <$Inner as rocket::request::FromParam<'r>>::Error;

            fn from_param(param: &'r str) -> std::result::Result<Self, Self::Error> {
                <$Inner as rocket::request::FromParam<'r>>::from_param(param).map(Self)
            }
        }
    };
}

and it would be used like this:

struct BookId(usize);
impl_FromParam_newtype!(BookId(usize));

However, I still think that supporting this feature in rocket itself would be beneficial.