How do I declare a struct that contains any kind of Deserializable/Serializable struct?

Question

I am trying to declare a struct that contains another struct of any given type that can be Deserialize and Serialize.

#[derive(Debug, Serialize, Deserialize)]
pub struct Foo<T: Deserialize + Serialize> {
    pub data: T,
}

Rust playground.

For that, I have tried to use trait bounds, using traits such as DeserializeOwned or Deserialize. Both have failed at compilation time with the following errors:

error[E0283]: type annotations required: cannot resolve `T: serde::Deserialize<'de>`
 --> src/main.rs:9:28
  |
9 | #[derive(Debug, Serialize, Deserialize)]
  |                            ^^^^^^^^^^^
  |
  = note: required by `serde::Deserialize`

error[E0637]: `&` without an explicit lifetime name cannot be used here
  --> src/main.rs:10:19
   |
10 | pub struct Foo<T: Deserialize + Serialize> {
   |                   ^^^^^^^^^^^ explicit lifetime name needed here

I faced errors trying to add a lifetime since I am not using storing a reference but a value.

What is the most idiomatic way of declaring this type of struct?

Answer 1

I found a solution thanks to a member of the Rust Discord who referred me to the following Github issue. The trick is not to use trait bounds but attribute bounds.

#[derive(Debug, Serialize, Deserialize)]
pub struct Foo<T> {
    #[serde(bound(
        serialize = "T: Serialize",
        deserialize = "T: Deserialize<'de>",
    ))]
    pub data: T,
}

Answer 2

Just don't place the bounds on the type:

use serde::{Deserialize, Serialize}; // 1.0.91

#[derive(Debug, Serialize, Deserialize)]
pub struct Foo<T> {
    pub data: T,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Boo {
    pub a: i64,
}

fn main() {
    let data = Boo { a: 1 };
    let wrap = Foo { data };
    println!("{:?}", wrap);
}

Then, place the bounds on methods where you need that behavior:

fn use_it<T>(foo: Foo<T>)
where
    Foo<T>: Serialize,
{
    // ...
}