value 模块与 IntoDeserializer

        impl<'de, E> de::Deserializer<'de> for $name<E>
        where
            E: de::Error,
        {
            type Error = E;

            forward_to_deserialize_any! {
                bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str
                string bytes byte_buf option unit unit_struct newtype_struct seq
                tuple tuple_struct map struct enum identifier ignored_any
            }

            fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
            where
                V: de::Visitor<'de>,
            {
                visitor.$method(self.value $($cast)*)
            }
        }

pub trait IntoDeserializer<'de, E: Error = value::Error> {
    /// The type of the deserializer being converted into.
    type Deserializer: Deserializer<'de, Error = E>;

    /// Convert this value into a deserializer.
    fn into_deserializer(self) -> Self::Deserializer;
}

            fn visit_i128<E>(self, value: i128) -> Result<Value, E>
            where
                E: serde::de::Error,
            {
                let de = serde::de::value::I128Deserializer::new(value);
                Number::deserialize(de).map(Value::Number)
            }

#[derive(Deserialize, Debug)]
enum Setting {
  On,
  Off,
}

impl FromStr for Setting {
  type Err = value::Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    Self::deserialize(s.into_deserializer())
  }
}

  println!("\"On\".parse()    = {:?}", "On".parse::<Setting>());
  println!("\"Maybe\".parse() = {:?}", "Maybe".parse::<Setting>());
  let e = "Maybe".parse::<Setting>().unwrap_err();
  println!("Display: {e}");

  // enum from variant index
  let by_index = Setting::deserialize(IntoDeserializer::<value::Error>::into_deserializer(1u32));
  println!("1u32 -> {by_index:?}");

"On".parse()    = Ok(On)
"Maybe".parse() = Err(Error("unknown variant `Maybe`, expected `On` or `Off`"))
Display: unknown variant `Maybe`, expected `On` or `Off`
1u32 -> Ok(Off)

    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
    where
        T: de::DeserializeSeed<'de>,
    {
        let value = self.value.take();
        // Panic because this indicates a bug in the program rather than an
        // expected failure.
        let value = value.expect("MapAccess::next_value called before next_key");
        seed.deserialize(value.into_deserializer())
    }

#[derive(Deserialize, Debug)]
struct Config {
  host: String,
  port: u16,
}

#[derive(Deserialize, Debug)]
struct Names {
  host: String,
  user: String,
}

// main 里：
  let mut env: HashMap<String, String> = HashMap::new();
  env.insert("host".into(), "localhost".into());
  env.insert("user".into(), "alice".into());
  let names = Names::deserialize(MapDeserializer::<_, value::Error>::new(env.clone().into_iter()));
  println!("Names  <- HashMap<String,String> : {names:?}");
  env.remove("user");
  env.insert("port".into(), "8080".into());
  let cfg = Config::deserialize(MapDeserializer::<_, value::Error>::new(env.into_iter()));
  println!("Config <- HashMap<String,String> : {cfg:?}");

  // same, but the values are serde_json::Value
  let mut m: BTreeMap<String, serde_json::Value> = BTreeMap::new();
  m.insert("host".into(), "localhost".into());
  m.insert("port".into(), 8080.into());
  let cfg = Config::deserialize(MapDeserializer::<_, serde_json::Error>::new(m.into_iter()));
  println!("Config <- BTreeMap<String,Value> : {cfg:?}");

Names  <- HashMap<String,String> : Ok(Names { host: "localhost", user: "alice" })
Config <- HashMap<String,String> : Err(Error("invalid type: string \"8080\", expected u16"))
Config <- BTreeMap<String,Value> : Ok(Config { host: "localhost", port: 8080 })

    pub fn end(self) -> Result<(), E> {
        let remaining = self.iter.count();
        if remaining == 0 {
            Ok(())
        } else {
            // First argument is the number of elements in the data, second
            // argument is the number of elements expected by the Deserialize.
            Err(de::Error::invalid_length(
                self.count + remaining,
                &ExpectedInSeq(self.count),
            ))
        }
    }

&str <- StrDeserializer         : Err(Error("invalid type: string \"borrowed?\", expected a borrowed string"))
&str <- BorrowedStrDeserializer : Ok("borrowed?")

use std::collections::BTreeMap;

use serde::Deserialize;
use serde::de::value::{BorrowedStrDeserializer, Error, MapDeserializer};

fn main() {
  let input = String::from("host=localhost;user=alice");
  let pairs = input.split(';').filter_map(|kv| kv.split_once('=')).map(|(k, v)| {
    (BorrowedStrDeserializer::<Error>::new(k), BorrowedStrDeserializer::<Error>::new(v))
  });
  let map = BTreeMap::<&str, &str>::deserialize(MapDeserializer::new(pairs)).unwrap();
  let host = map["host"];
  println!("{map:?}");
  println!("host points into input: {}", input.as_ptr() as usize == host.as_ptr() as usize - "host=".len());
}

{"host": "localhost", "user": "alice"}
host points into input: true

#[derive(Deserialize, Debug)]
struct Image {
  name: String,
  #[serde(default = "latest")]
  tag: String,
}

fn latest() -> String {
  "latest".into()
}

// Accepts "nginx" or {"name": "nginx", "tag": "1.27"}.
fn string_or_struct<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Image, D::Error> {
  struct V;

  impl<'de> Visitor<'de> for V {
    type Value = Image;

    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
      f.write_str("an image name or an image struct")
    }

    fn visit_str<E: de::Error>(self, s: &str) -> Result<Image, E> {
      Ok(Image { name: s.to_owned(), tag: latest() })
    }

    fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Image, A::Error> {
      // Hand the half-consumed map to the derived impl.
      Image::deserialize(MapAccessDeserializer::new(map))
    }
  }

  deserializer.deserialize_any(V)
}

#[derive(Deserialize, Debug)]
struct Service {
  #[serde(deserialize_with = "string_or_struct")]
  image: Image,
}

{"image":"nginx"}                          Ok(Service { image: Image { name: "nginx", tag: "latest" } })
{"image":{"name":"nginx","tag":"1.27"}}    Ok(Service { image: Image { name: "nginx", tag: "1.27" } })
{"image":{"tag":"1.27"}}                   Err("missing field `name` at line 1 column 23")
{"image":7}                                Err("invalid type: integer `7`, expected an image name or an image struct at line 1 column 10")

#[derive(Clone, PartialEq)]
pub struct Error {
    err: ErrorImpl,
}

#[cfg(any(feature = "std", feature = "alloc"))]
type ErrorImpl = Box<str>;
#[cfg(not(any(feature = "std", feature = "alloc")))]
type ErrorImpl = ();

(u8,u8) <- vec![1,2,3] : Err(Error("invalid length 3, expected 2 elements in sequence"))
(u8,u8,u8) <- vec![1,2] : Err(Error("invalid length 2, expected a tuple of size 3"))