invalid type: string "...", expected a borrowed string

use std::collections::HashMap;
use std::fmt::Debug;

use serde::Deserialize;

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
struct Post<'a> {
  title: &'a str,
}

fn show<T: Debug>(label: &str, r: serde_json::Result<T>) {
  match r {
    Ok(v) => println!("{label:<24} Ok({v:?})"),
    Err(e) => println!("{label:<24} Err({e})"),
  }
}

fn main() {
  // a JSON unicode escape: backslash, 'u', 00e9 (Python's json.dumps writes these by default)
  let unicode = format!(r#"{{"title":"caf{}u00e9"}}"#, '\\');
  for input in [r#"{"title":"hello"}"#, r#"{"title":"a/b"}"#, r#"{"title":"say \"hi\""}"#, &unicode] {
    show(input, serde_json::from_str::<Post>(input));
  }
  // map keys borrow too
  show(r#"{"a\nb":1} as map"#, serde_json::from_str::<HashMap<&str, u32>>(r#"{"a\nb":1}"#));
}

{"title":"hello"}        Ok(Post { title: "hello" })
{"title":"a/b"}          Ok(Post { title: "a/b" })
{"title":"say \"hi\""}   Err(invalid type: string "say \"hi\"", expected a borrowed string at line 1 column 21)
{"title":"caf\u00e9"}    Err(invalid type: string "café", expected a borrowed string at line 1 column 20)
{"a\nb":1} as map        Err(invalid type: string "a\nb", expected a borrowed string at line 1 column 7)

use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct Post<'a> {
  title: &'a str,
}

fn main() {
  let file = std::fs::File::open("post.json").unwrap();
  let p: Post = serde_json::from_reader(file).unwrap();
  println!("{p:?}");
}

error: implementation of `Deserialize` is not general enough
  --> src/bin/bs_reader.rs:10:17
   |
10 |   let p: Post = serde_json::from_reader(file).unwrap();
   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Deserialize` is not general enough
   |
   = note: `Post<'_>` must implement `Deserialize<'0>`, for any lifetime `'0`...
   = note: ...but `Post<'_>` actually implements `Deserialize<'1>`, for some specific lifetime `'1`

error: could not compile `exp-serde-pit3` (bin "bs_reader") due to 1 previous error

    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: Error,
    {
        Err(Error::invalid_type(Unexpected::Str(v), &self))
    }

        match tri!(self.de.read.parse_str(&mut self.de.scratch)) {
            Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
            Reference::Copied(s) => visitor.visit_str(s),
        }

use std::borrow::Cow;

use serde::Deserialize;
use serde_with::{BorrowCow, serde_as};

#[serde_as]
#[derive(Deserialize)]
struct Fixed<'a> {
  owned: String,
  #[serde(borrow)]
  cow: Cow<'a, str>,
  #[serde(borrow)]
  opt_cow: Option<Cow<'a, str>>,
  #[serde_as(as = "Option<BorrowCow>")]
  #[serde(borrow)]
  opt_with: Option<Cow<'a, str>>,
  #[serde_as(as = "Vec<BorrowCow>")]
  #[serde(borrow)]
  vec_with: Vec<Cow<'a, str>>,
}

fn kind(c: &Cow<str>) -> &'static str {
  match c {
    Cow::Borrowed(_) => "Borrowed",
    Cow::Owned(_) => "Owned",
  }
}

fn main() {
  for s in ["hello", r#"say \"hi\""#] {
    let input = format!(
      r#"{{"owned":"{s}","cow":"{s}","opt_cow":"{s}","opt_with":"{s}","vec_with":["{s}"]}}"#
    );
    let f: Fixed = serde_json::from_str(&input).unwrap();
    println!(
      "{s:<12} owned={:?} cow={} opt_cow={} opt_with={} vec_with[0]={}",
      f.owned,
      kind(&f.cow),
      kind(f.opt_cow.as_ref().unwrap()),
      kind(f.opt_with.as_ref().unwrap()),
      kind(&f.vec_with[0]),
    );
  }
}

hello        owned="hello" cow=Borrowed opt_cow=Owned opt_with=Borrowed vec_with[0]=Borrowed
say \"hi\"   owned="say \"hi\"" cow=Owned opt_cow=Owned opt_with=Owned vec_with[0]=Owned

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
struct Post<'a> {
  // no #[serde(borrow)]: Option<&str> is implicitly borrowed, like &str
  subtitle: Option<&'a str>,
}

// main 里对三种输入各调一次 from_str::<Post>，打印 Ok / Err

{"subtitle":"hello"}   Ok(Post { subtitle: Some("hello") })
{"subtitle":null}      Ok(Post { subtitle: None })
{"subtitle":"a\"b"}    Err(invalid type: string "a\"b", expected a borrowed string at line 1 column 18)

use serde::Deserialize;

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
struct Post<'a> {
  title: &'a str,
}

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
struct OwnedPost {
  title: String,
}

fn main() {
  std::fs::write("post.json", r#"{"title":"hello"}"#).unwrap();

  // 1. keep the borrowed type: read the whole file first, then borrow from the String
  let text = std::fs::read_to_string("post.json").unwrap();
  let p: Post = serde_json::from_str(&text).unwrap();
  println!("from_str(&text):  {p:?}");

  // 2. keep from_reader: make the type own its data
  let file = std::io::BufReader::new(std::fs::File::open("post.json").unwrap());
  let o: OwnedPost = serde_json::from_reader(file).unwrap();
  println!("from_reader:      {o:?}");
}

from_str(&text):  Post { title: "hello" }
from_reader:      OwnedPost { title: "hello" }