the trait bound Rc<std::string::String>: serde::Serialize is not satisfied

use std::rc::Rc;

use serde::Serialize;

#[derive(Serialize)]
struct Post {
  title: Rc<String>,
}

fn main() {
  let p = Post { title: Rc::new("hello".to_string()) };
  println!("{}", serde_json::to_string(&p).unwrap());
}

error[E0277]: the trait bound `Rc<std::string::String>: serde::Serialize` is not satisfied
    --> src/bin/rc_derive.rs:5:10
     |
   5 | #[derive(Serialize)]
     |          ^^^^^^^^^ the trait `Serialize` is not implemented for `Rc<std::string::String>`
   6 | struct Post {
   7 |   title: Rc<String>,
     |   ----- required by a bound introduced by this call
     |
     = note: for local types consider adding `#[derive(serde::Serialize)]` to your `Rc<std::string::String>` type
     = note: for types from other crates check whether the crate offers a `serde` feature flag
     = help: the following other types implement trait `Serialize`:
               &'a T
               &'a mut T
               ()
               (T,)
               (T0, T1)
               (T0, T1, T2)
               (T0, T1, T2, T3)
               (T0, T1, T2, T3, T4)
             and 130 others
note: required by a bound in `_serde::ser::SerializeStruct::serialize_field`
    --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_core-1.0.229/src/ser/mod.rs:1917:21
     |
1915 |     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
     |        --------------- required by a bound in this associated function
1916 |     where
1917 |         T: ?Sized + Serialize;
     |                     ^^^^^^^^^ required by this bound in `SerializeStruct::serialize_field`
     = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0277`.
error: could not compile `exp-serde-pit3-norc` (bin "rc_derive") due to 1 previous error

error[E0277]: the trait bound `Arc<[std::string::String]>: serde::Serialize` is not satisfied
    --> src/bin/rc_direct.rs:5:40
     |
   5 |   println!("{}", serde_json::to_string(&tags).unwrap());
     |                  --------------------- ^^^^^ the trait `serde_core::ser::Serialize` is not implemented for `Arc<[std::string::String]>`

    #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
    #[cfg_attr(docsrs, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
    <T> Serialize for Rc<T> where T: ?Sized + Serialize

    diagnostic::on_unimplemented(
        // Prevents `serde_core::ser::Serialize` appearing in the error message
        // in projects with no direct dependency on serde_core.
        message = "the trait bound `{Self}: serde::Serialize` is not satisfied",
        note = "for local types consider adding `#[derive(serde::Serialize)]` to your `{Self}` type",
        note = "for types from other crates check whether the crate offers a `serde` feature flag",
    )

use std::cell::RefCell;
use std::rc::{Rc, Weak};

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct Pair {
  a: Rc<RefCell<String>>,
  b: Rc<RefCell<String>>,
}

#[derive(Serialize, Deserialize, Debug)]
struct Child {
  name: String,
  parent: Weak<String>,
}

fn main() {
  let shared = Rc::new(RefCell::new("hello".to_string()));
  let pair = Pair { a: shared.clone(), b: shared };
  let json = serde_json::to_string(&pair).unwrap();
  println!("json: {json}");

  let back: Pair = serde_json::from_str(&json).unwrap();
  back.a.borrow_mut().push_str(", world");
  println!(
    "before: ptr_eq={} strong={} | after: ptr_eq={} strong={} b={:?}",
    Rc::ptr_eq(&pair.a, &pair.b),
    Rc::strong_count(&pair.a),
    Rc::ptr_eq(&back.a, &back.b),
    Rc::strong_count(&back.a),
    back.b.borrow(),
  );

  let parent = Rc::new("root".to_string());
  let child = Child { name: "leaf".into(), parent: Rc::downgrade(&parent) };
  let json = serde_json::to_string(&child).unwrap();
  let back: Child = serde_json::from_str(&json).unwrap();
  println!("Weak: json={json} upgrade after round trip={:?}", back.parent.upgrade());
}

json: {"a":"hello","b":"hello"}
before: ptr_eq=true strong=2 | after: ptr_eq=false strong=1 b="hello"
Weak: json={"name":"leaf","parent":"root"} upgrade after round trip=None

use std::rc::Rc;

use serde::{Deserialize, Serialize};

// In memory: two posts share one author.
struct Post {
  title: String,
  author: Rc<String>,
}

// On the wire: the author is stored once and referred to by index.
#[derive(Serialize, Deserialize)]
struct Wire {
  authors: Vec<String>,
  posts: Vec<(String, usize)>,
}

fn to_wire(posts: &[Post]) -> Wire {
  let mut authors: Vec<Rc<String>> = vec![];
  let mut out = vec![];
  for p in posts {
    let i = match authors.iter().position(|a| Rc::ptr_eq(a, &p.author)) {
      Some(i) => i,
      None => {
        authors.push(p.author.clone());
        authors.len() - 1
      }
    };
    out.push((p.title.clone(), i));
  }
  Wire { authors: authors.iter().map(|a| a.to_string()).collect(), posts: out }
}

fn from_wire(w: Wire) -> Vec<Post> {
  let authors: Vec<Rc<String>> = w.authors.into_iter().map(Rc::new).collect();
  w.posts.into_iter().map(|(title, i)| Post { title, author: authors[i].clone() }).collect()
}

fn main() {
  let alice = Rc::new("alice".to_string());
  let posts = vec![
    Post { title: "a".into(), author: alice.clone() },
    Post { title: "b".into(), author: alice },
  ];
  let json = serde_json::to_string(&to_wire(&posts)).unwrap();
  let back = from_wire(serde_json::from_str(&json).unwrap());
  println!("json: {json}");
  println!("after: ptr_eq={} strong={}", Rc::ptr_eq(&back[0].author, &back[1].author), Rc::strong_count(&back[0].author));
}

json: {"authors":["alice"],"posts":[["a",0],["b",0]]}
after: ptr_eq=true strong=2

{"title":"hello"}

├── serde feature "rc"
│   └── enabler v0.1.0 (exp-serde-pit3/unify/enabler) (*)