Bincode does not support the serde::Deserializer::deserialize_any method

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(tag = "t")]
enum Internal {
  Rec { id: u32 },
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct SkipIf {
  #[serde(skip_serializing_if = "Option::is_none")]
  note: Option<String>,
  id: u32,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum Gap {
  A,
  #[serde(skip_deserializing)]
  B,
  C,
}

// Serialize only the even numbers: the iterator does not know its length.
#[derive(Deserialize, Debug, PartialEq)]
struct Evens(Vec<u32>);

impl Serialize for Evens {
  fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    s.collect_seq(self.0.iter().filter(|n| *n % 2 == 0))
  }
}

// ... Plain、External、Adjacent、Untagged、Flat、Skip、GapLast、WithValue 同理

fn cell<E: std::fmt::Display, T: Debug + PartialEq>(orig: &T, ser: Result<Vec<u8>, E>, de: impl Fn(&[u8]) -> Result<T, String>) -> String {
  match ser {
    Err(e) => format!("ser Err({e})"),
    Ok(bytes) => match de(&bytes) {
      Ok(back) if &back == orig => format!("{bytes:?} -> same"),
      Ok(back) => format!("{bytes:?} -> DIFFERENT {back:?}"),
      Err(e) => format!("{bytes:?} -> de Err({e})"),
    },
  }
}

fn row<T: Serialize + DeserializeOwned + Debug + PartialEq>(label: &str, v: T) {
  println!("{label}: {v:?}");
  let b = cell(&v, bincode::serialize(&v), |b| bincode::deserialize::<T>(b).map_err(|e| e.to_string()));
  println!("  bincode  {b}");
  let p = cell(&v, postcard::to_allocvec(&v), |b| postcard::from_bytes::<T>(b).map_err(|e| e.to_string()));
  println!("  postcard {p}");
  // ... serde_json 同样往返，打印 JSON 文本
}

plain struct: Plain { id: 7, name: "a" }
  bincode  [7, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 97] -> same
  postcard [7, 1, 97] -> same
  json     {"id":7,"name":"a"} -> same
external unit: Unit
  bincode  [0, 0, 0, 0] -> same
  postcard [0] -> same
  json     "Unit" -> same
external newtype: New(7)
  bincode  [1, 0, 0, 0, 7, 0, 0, 0] -> same
  postcard [1, 7] -> same
  json     {"New":7} -> same
external struct: Rec { id: 7 }
  bincode  [2, 0, 0, 0, 7, 0, 0, 0] -> same
  postcard [2, 7] -> same
  json     {"Rec":{"id":7}} -> same
internal: Rec { id: 7 }
  bincode  [3, 0, 0, 0, 0, 0, 0, 0, 82, 101, 99, 7, 0, 0, 0] -> de Err(Bincode does not support the serde::Deserializer::deserialize_any method)
  postcard [3, 82, 101, 99, 7] -> de Err(This is a feature that PostCard will never implement)
  json     {"t":"Rec","id":7} -> same
adjacent: New(7)
  bincode  [0, 0, 0, 0, 7, 0, 0, 0] -> de Err(Bincode does not support Deserializer::deserialize_identifier)
  postcard [0, 7] -> de Err(This is a feature that PostCard will never implement)
  json     {"t":"New","c":7} -> same
untagged: New(7)
  bincode  [7, 0, 0, 0] -> de Err(Bincode does not support the serde::Deserializer::deserialize_any method)
  postcard [7] -> de Err(This is a feature that PostCard will never implement)
  json     7 -> same
flatten: Flat { id: 7, inner: Inner { name: "a" } }
  bincode  ser Err(Bincode can only encode sequences and maps that have a knowable size ahead of time)
  postcard ser Err(The length of a sequence must be known)
  json     {"id":7,"name":"a"} -> same
skip_serializing_if, None: SkipIf { note: None, id: 7 }
  bincode  [7, 0, 0, 0] -> de Err(tag for enum is not valid, found 7)
  postcard [7] -> de Err(Found an Option discriminant that wasn't 0 or 1)
  json     {"id":7} -> same
skip_serializing_if, None, id 1: SkipIf { note: None, id: 1 }
  bincode  [1, 0, 0, 0] -> de Err(io error: unexpected end of file)
  postcard [1] -> de Err(Hit the end of buffer, expected more data)
  json     {"id":1} -> same
skip_serializing_if, Some: SkipIf { note: Some("a"), id: 7 }
  bincode  [1, 1, 0, 0, 0, 0, 0, 0, 0, 97, 7, 0, 0, 0] -> same
  postcard [1, 1, 97, 7] -> same
  json     {"note":"a","id":7} -> same
skip: Skip { cache: None, id: 7 }
  bincode  [7, 0, 0, 0] -> same
  postcard [7] -> same
  json     {"id":7} -> same
skip_deserializing variant, A: A
  bincode  [0, 0, 0, 0] -> same
  postcard [0] -> same
  json     "A" -> same
skip_deserializing variant, B: B
  bincode  [1, 0, 0, 0] -> DIFFERENT C
  postcard [1] -> DIFFERENT C
  json     "B" -> de Err(unknown variant `B`, expected `A` or `C` at line 1 column 3)
skip_deserializing variant, C: C
  bincode  [2, 0, 0, 0] -> de Err(invalid value: integer `2`, expected variant index 0 <= i < 2)
  postcard [2] -> de Err(Serde Deserialization Error)
  json     "C" -> same
skipped variant last, C: C
  bincode  [1, 0, 0, 0] -> same
  postcard [1] -> same
  json     "C" -> same
skipped variant last, B: B
  bincode  [2, 0, 0, 0] -> de Err(invalid value: integer `2`, expected variant index 0 <= i < 2)
  postcard [2] -> de Err(Serde Deserialization Error)
  json     "B" -> de Err(unknown variant `B`, expected `A` or `C` at line 1 column 3)
collect_seq(filter): Evens([2, 4])
  bincode  ser Err(Bincode can only encode sequences and maps that have a knowable size ahead of time)
  postcard ser Err(The length of a sequence must be known)
  json     [2,4] -> same
serde_json::Value: WithValue { v: Number(7) }
  bincode  [7, 0, 0, 0, 0, 0, 0, 0] -> de Err(Bincode does not support the serde::Deserializer::deserialize_any method)
  postcard [7] -> de Err(This is a feature that PostCard will never implement)
  json     {"v":7} -> same

    #[inline]
    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
        let _ = key;
        Ok(())
    }

        let u64_mapping = deserialized_fields.iter().enumerate().map(|(i, field)| {
            let i = i as u64;
            let ident = &field.ident;
            quote!(#i => _serde::#private::Ok(#this_value::#ident))
        });

fn roundtrip<T: Serialize + DeserializeOwned + PartialEq + std::fmt::Debug>(v: &T) {
  let bytes = bincode::serialize(v).unwrap();
  assert_eq!(&bincode::deserialize::<T>(&bytes).unwrap(), v);
  let bytes = postcard::to_allocvec(v).unwrap();
  assert_eq!(&postcard::from_bytes::<T>(&bytes).unwrap(), v);
}