标准库类型的实现

primitive_impl!(isize, serialize_i64 as i64);
// ...
primitive_impl!(usize, serialize_u64 as u64);

impl_deserialize_num! {
    u8, NonZeroU8, deserialize_u8
    num_self!(u8:visit_u8);
    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
    uint_to_self!(u16:visit_u16 u32:visit_u32 u64:visit_u64);
}

macro_rules! uint_to_self {
    ($ty:ident : $visit:ident) => {
        #[inline]
        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
        where
            E: Error,
        {
            Self::Value::try_from(v as u64)
                .map_err(|_| Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
        }
    };
    // ...
}

use std::num::{NonZeroU8, Saturating, Wrapping};

fn show<T: serde::de::DeserializeOwned + std::fmt::Debug>(ty: &str, input: &str) {
  match serde_json::from_str::<T>(input) {
    Ok(v) => println!("{ty:<14} <- {input:<6} Ok({v:?})"),
    Err(e) => println!("{ty:<14} <- {input:<6} Err({e})"),
  }
}

fn main() {
  for input in ["255", "300", "-1", "1.0", "1e2", "\"1\""] {
    show::<u8>("u8", input);
  }
  show::<i8>("i8", "200");
  show::<u64>("u64", "-1");
  show::<f32>("f32", "300");
  show::<NonZeroU8>("NonZeroU8", "0");
  show::<NonZeroU8>("NonZeroU8", "300");
  show::<Saturating<u8>>("Saturating<u8>", "300");
  show::<Saturating<u8>>("Saturating<u8>", "-1");
  show::<Wrapping<u8>>("Wrapping<u8>", "300");
  show::<u128>("u128", "340282366920938463463374607431768211455");
  show::<char>("char", "\"ab\"");
}

u8             <- 255    Ok(255)
u8             <- 300    Err(invalid value: integer `300`, expected u8 at line 1 column 3)
u8             <- -1     Err(invalid value: integer `-1`, expected u8 at line 1 column 2)
u8             <- 1.0    Err(invalid type: floating point `1.0`, expected u8 at line 1 column 3)
u8             <- 1e2    Err(invalid type: floating point `100.0`, expected u8 at line 1 column 3)
u8             <- "1"    Err(invalid type: string "1", expected u8 at line 1 column 3)
i8             <- 200    Err(invalid value: integer `200`, expected i8 at line 1 column 3)
u64            <- -1     Err(invalid value: integer `-1`, expected u64 at line 1 column 2)
f32            <- 300    Ok(300.0)
NonZeroU8      <- 0      Err(invalid value: integer `0`, expected a nonzero u8 at line 1 column 1)
NonZeroU8      <- 300    Err(invalid value: integer `300`, expected a nonzero u8 at line 1 column 3)
Saturating<u8> <- 300    Ok(255)
Saturating<u8> <- -1     Ok(0)
Wrapping<u8>   <- 300    Err(invalid value: integer `300`, expected u8 at line 1 column 3)
u128           <- 340282366920938463463374607431768211455 Ok(340282366920938463463374607431768211455)
char           <- "ab"   Err(invalid value: string "ab", expected a character at line 1 column 4)

    #[inline]
    fn visit_unit<E>(self) -> Result<Self::Value, E>
    where
        E: Error,
    {
        Ok(None)
    }

    #[inline]
    fn visit_none<E>(self) -> Result<Self::Value, E>
    where
        E: Error,
    {
        Ok(None)
    }

    #[inline]
    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    where
        D: Deserializer<'de>,
    {
        T::deserialize(deserializer).map(Some)
    }

Option<Option<u8>> <- null : None
Some(None::<u8>) -> null

            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: SeqAccess<'de>,
            {
                let capacity = size_hint::cautious::<T>(seq.size_hint());
                let mut values = Vec::<T>::with_capacity(capacity);

                while let Some(value) = tri!(seq.next_element()) {
                    values.push(value);
                }

                Ok(values)
            }

pub fn cautious<Element>(hint: Option<usize>) -> usize {
    const MAX_PREALLOC_BYTES: usize = 1024 * 1024;

    if mem::size_of::<Element>() == 0 {
        0
    } else {
        cmp::min(
            hint.unwrap_or(0),
            MAX_PREALLOC_BYTES / mem::size_of::<Element>(),
        )
    }
}

fn main() {
  // bincode 1.x: a Vec is a u64 length prefix followed by the elements.
  let mut evil = Vec::new();
  evil.extend_from_slice(&(1u64 << 40).to_le_bytes()); // claims 2^40 elements
  evil.extend_from_slice(&[0u8; 16]); // but only 16 bytes follow

  let (r, max) = biggest(|| bincode::deserialize::<Vec<u64>>(&evil));
  println!("Vec<u64>  : {:?}, largest alloc = {max} bytes", r.map(|v| v.len()));
  let (r, max) = biggest(|| bincode::deserialize::<Vec<u8>>(&evil));
  println!("Vec<u8>   : {:?}, largest alloc = {max} bytes", r.map(|v| v.len()));
  let (r, max) = biggest(|| bincode::deserialize::<Vec<[u64; 32]>>(&evil));
  println!("Vec<[u64; 32]>: {:?}, largest alloc = {max} bytes", r.map(|v| v.len()));
  // Zero-sized elements need no input bytes, so keep this claim small.
  let units = bincode::serialize(&(1u64 << 20)).unwrap();
  let (r, max) = biggest(|| bincode::deserialize::<Vec<()>>(&units));
  println!("Vec<()>   : {:?}, largest alloc = {max} bytes", r.map(|v| v.len()));

  // Exact hint vs no hint.
  let ten: Vec<u32> = (0..10).collect();
  let from_bincode: Vec<u32> = bincode::deserialize(&bincode::serialize(&ten).unwrap()).unwrap();
  let from_json: Vec<u32> = serde_json::from_str(&serde_json::to_string(&ten).unwrap()).unwrap();
  println!("bincode: len {} cap {}", from_bincode.len(), from_bincode.capacity());
  println!("json   : len {} cap {}", from_json.len(), from_json.capacity());
}

Vec<u64>  : Err(Io(Kind(UnexpectedEof))), largest alloc = 1048576 bytes
Vec<u8>   : Err(Io(Kind(UnexpectedEof))), largest alloc = 1048576 bytes
Vec<[u64; 32]>: Err(Io(Kind(UnexpectedEof))), largest alloc = 1048576 bytes
Vec<()>   : Ok(1048576), largest alloc = 0 bytes
bincode: len 10 cap 10
json   : len 10 cap 16

                    fn visit_map<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
                    where
                        A: MapAccess<'de>,
                    {
                        let mut values = $with_capacity;

                        while let Some((key, value)) = tri!($access.next_entry()) {
                            values.insert(key, value);
                        }

                        Ok(values)
                    }

HashMap <- {"a":1,"a":2} : {"a": 2}
Point   <- {"x":1,"x":2} : Err("duplicate field `x` at line 1 column 10")
BTreeMap -> {"a":1,"b":2}

        impl<'de, T> Deserialize<'de> for $t<T>
        where
            T: ?Sized,
            Box<T>: Deserialize<'de>,
        {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                Box::deserialize(deserializer).map(Into::into)
            }
        }

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

// main 里：
  let shared = Rc::new("hello".to_string());
  let pair = Pair { a: shared.clone(), b: shared.clone() };
  let json = serde_json::to_string(&pair).unwrap();
  println!("Pair -> {json}");
  let back: Pair = serde_json::from_str(&json).unwrap();
  println!(
    "before: ptr_eq={} strong={}; after: ptr_eq={} strong(a)={} 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),
    Rc::strong_count(&back.b)
  );
  let w: Weak<String> = serde_json::from_str("\"hello\"").unwrap();
  println!("Weak <- \"hello\" : upgrade = {:?}", w.upgrade());
  let dangling = Rc::downgrade(&Rc::new(1u8));
  println!("dead Weak -> {}", serde_json::to_string(&dangling).unwrap());

Pair -> {"a":"hello","b":"hello"}
before: ptr_eq=true strong=3; after: ptr_eq=false strong(a)=1 strong(b)=1
Weak <- "hello" : upgrade = None
dead Weak -> null

error[E0277]: the trait bound `Rc<std::string::String>: serde::Serialize` is not satisfied
    --> src/main.rs:5:10
     |
   5 | #[derive(Serialize)]
     |          ^^^^^^^^^ the trait `Serialize` is not implemented for `Rc<std::string::String>`
   6 | struct Pair {
   7 |   a: Rc<String>,
     |   - required by a bound introduced by this call

        let mut state = tri!(serializer.serialize_struct("Duration", 2));
        tri!(state.serialize_field("secs", &self.as_secs()));
        tri!(state.serialize_field("nanos", &self.subsec_nanos()));
        state.end()

// This is a cleaned-up version of the impl generated by:
//
//     #[derive(Deserialize)]
//     #[serde(deny_unknown_fields)]
//     struct Duration {
//         secs: u64,
//         nanos: u32,
//     }

Duration -> {"secs":1,"nanos":500000000}
SystemTime -> {"secs_since_epoch":1700000000,"nanos_since_epoch":5}
SystemTime(before epoch) -> Err("SystemTime must be later than UNIX_EPOCH")
Duration <- [1, 2000000000] : 3s
Duration <- {"secs":1} : Err("missing field `nanos` at line 1 column 10")
Duration <- [u64::MAX, 1e9] : Err("overflow deserializing Duration at line 1 column 34")

PhantomData -> null
PhantomData <- 0 : Err("invalid type: integer `0`, expected unit at line 1 column 1")

    #[inline]
    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
    where
        A: MapAccess<'de>,
    {
        while let Some((IgnoredAny, IgnoredAny)) = tri!(map.next_entry()) {
            // Gobble
        }
        Ok(IgnoredAny)
    }

            _ => { let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; }

IgnoredAny <- nested : IgnoredAny
(IgnoredAny, IgnoredAny, u8) : 7

Result::Err -> {"Err":"boom"}
Result <- {"Ok":3} : Ok(3)

        if serializer.is_human_readable() {
            match *self {
                net::IpAddr::V4(ref a) => a.serialize(serializer),
                net::IpAddr::V6(ref a) => a.serialize(serializer),
            }
        } else {
            match *self {
                net::IpAddr::V4(ref a) => {
                    serializer.serialize_newtype_variant("IpAddr", 0, "V4", a)
                }
                net::IpAddr::V6(ref a) => {
                    serializer.serialize_newtype_variant("IpAddr", 1, "V6", a)
                }
            }
        }

IpAddr     json="127.0.0.1" bincode=[0, 0, 0, 0, 127, 0, 0, 1]
SocketAddr json="127.0.0.1:8080" bincode=[0, 0, 0, 0, 127, 0, 0, 1, 144, 31]
IpAddr <- "300.0.0.1" : Err("invalid IP address syntax at line 1 column 11")

u8   <- 5u128 : Err(Error("invalid type: integer `5` as u128, expected u8"))
u64  <- 5u128 : Err(Error("invalid type: integer `5` as u128, expected u64"))
i128 <- 5u128 : Ok(5)
u128 <- 5u8   : Ok(5)