Derive macro should support a way to specify concrete types for generics

[thou-vow]

struct Type1;
struct Type2;

struct Struct<T>

It's currently not possible to derive only for Struct<Type1> for example.
The implementation for this could be pretty similar to #[serde(bound)], however it would need it's own parser.
I don't know if there's any syntax standard for this kind of clause anywhere, so I just brainstormed one.

#[derive(Serialize)]
#[serde(select = "T = u32|u64, U = bool || U  = String" )]
struct Struct<T, U> {}

// Which expands to...
impl Serialize for Struct<u32, bool> {}
impl Serialize for Struct<u64, bool> {}
impl<T> Serialize for Struct<T, String> {}

Whenever the same generic type is used by this attribute and #[serde(bound)], it could output an error. However, I believe there's no reason for trait bounds to not belong to this attribute too.

#[derive(Serialize)]
#[serde(select = "T = u32|u64, U: Clone || U = String" )]
struct Struct<T, U> {}

// Which expands to...
impl<U> Serialize for Struct<u32, U> where U: Clone {}
impl<U> Serialize for Struct<u64, U> where U: Clone {}
impl<T> Serialize for Struct<T, String> {} 

[Mingun]

In think, if do something like that, no need to introduce ambiguous syntaxes (for example, I read your definition as (T = u32|u64), (U = bool || U = String)). Instead, just explicitly enumerate all variants:

#[derive(Serialize)]
#[serde(select = "T = u32, U: Clone")]
#[serde(select = "T = u64, U: Clone")]
#[serde(select = "U = String")]
struct Struct<T, U> {}

[thou-vow]

I agree, maintaining a DSL just for this seems too excessive.

#[derive(Serialize)]
#[serde(with = "T = u32", bound = "U: Clone")]
#[serde(with = "T = u64", bound = "U: Clone")]
#[serde(with = "U = String")]
struct Struct<T, U> {}

I think this could fit better since there's no overlap of functionality.
But whenever there's a divergence between Deserialize and Serialize, it looks a bit confusing.

#[derive(Deserialize, Serialize)]
#[serde(
    with(serialize = "T = u32", deserialize = "T = i32"),
    bound(serialize = "U: Clone"),
)]
struct Struct<T, U> {}