Type-safe delegation over generics in Rust without the newtype pattern

delegate.md

pub struct GenericId<T>(pub i64, pub PhantomData<T>);

pub struct PhantomMyId;
pub type MyId = GenericId<PhantomMyId>;
pub struct PhantomOtherId;
pub type OtherId = GenericId<PhantomOtherId>;


pub fn foo(my_id: &MyId){

}

1. It is type-safe; MyId!=OtherId.
2. The delegate is transparent — no additional effort is required to call the delegate’s methods.
3. You can use derive or the derive_more crate.

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Validate, From, Into, new)]
#[serde(transparent)]
pub struct GenericSecret<T: Validate<Context = ()> + AsRef<String>(
    #[garde(dive)] pub T,
    #[new(default)]
    #[garde(skip)]
    pub PhantomData<()>,
);

impl<T: Validate<Context = ()> + AsRef<String>> GenericSecret<T> {
    pub fn expose_secret(&self) -> &str {
        self.0.as_ref()
    }
}

impl<T: Validate<Context = ()> + AsRef<String>> Display
    for GenericSecret<T>
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "***")
    }
}

impl<T: Validate<Context = ()> + AsRef<String>> Debug
    for GenericSecret<T>
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "AccessToken(\"***\")")
    }
}

#[derive(Validate, AsRef)]
struct ValidatedAccessToken(#[garde(ascii, length(max = 4096))] String);

pub type AccessToken = GenericSecret<ValidatedAccessToken>;

#[derive(Validate, AsRef)]
struct ValidatedRefreshToken(#[garde(ascii, length(max = 4096))] String);

pub type RefreshToken = GenericSecret<ValidatedRefreshToken>;

This is a kind of inheritance (sugar), where concrete implementations of ValidatedAccessToken "inherit" the methods of their ancestor GenericSecret.

pub trait GenericSecretTrait: Debug + AsRef<String> {
    fn expose_secret(&self) -> &str {
        self.as_ref()
    }
}

*error*: type parameter `T` must be used as the type parameter for some local type. 
impl<T: GenericSecretTrait> Debug for T {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "***")
    }
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Validate, From, Into, new, AsRef)]
#[serde(transparent)]
pub struct GenericSecretTraitBased(#[garde(skip)] pub String);

impl GenericSecretTrait for GenericSecretTraitBased {}

The method described above is the shortest approach I've found to provide default trait implementations for many child types.