key must be a string

use std::collections::{BTreeMap, HashMap};

use serde::Serialize;

#[derive(Serialize, PartialEq, Eq, Hash)]
struct Cell {
  row: u32,
  col: u32,
}

#[derive(Serialize)]
struct Board {
  cells: HashMap<(u32, u32), char>,
}

fn main() {
  let mut cells = HashMap::new();
  cells.insert((0, 1), 'x');
  println!("tuple-key map:         {:?}", serde_json::to_string(&Board { cells }));

  let mut by_cell = HashMap::new();
  by_cell.insert(Cell { row: 0, col: 1 }, 'x');
  println!("struct-key map:        {:?}", serde_json::to_string(&by_cell));

  let mut opt = BTreeMap::new();
  opt.insert(Some("a"), 1);
  println!("Option key, to_string: {:?}", serde_json::to_string(&opt));
  println!("Option key, to_value:  {:?}", serde_json::to_value(&opt));
  opt.insert(None, 2);
  println!("None key, to_string:   {:?}", serde_json::to_string(&opt));

  // f64 is not Ord/Hash; a Vec of pairs serialized as a map shows the float key path
  let floats: Vec<(f64, u32)> = vec![(1.5, 1), (f64::NAN, 2)];
  let as_map = serde_json::to_string(&FloatMap(&floats));
  println!("f64 keys with NaN:     {as_map:?}");
}

struct FloatMap<'a>(&'a [(f64, u32)]);

impl Serialize for FloatMap<'_> {
  fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    s.collect_map(self.0.iter().map(|(k, v)| (k, v)))
  }
}

tuple-key map:         Err(Error("key must be a string", line: 0, column: 0))
struct-key map:        Err(Error("key must be a string", line: 0, column: 0))
Option key, to_string: Ok("{\"a\":1}")
Option key, to_value:  Err(Error("key must be a string", line: 0, column: 0))
None key, to_string:   Err(Error("key must be a string", line: 0, column: 0))
f64 keys with NaN:     Err(Error("float key must be finite (got NaN or +/-inf)", line: 0, column: 0))

#[derive(Serialize)]
struct Board {
  name: &'static str,
  cells: BTreeMap<(u32, u32), char>,
}

fn main() {
  let board = Board { name: "demo", cells: BTreeMap::from([((0, 1), 'x')]) };
  let mut out = Vec::new();
  let r = serde_json::to_writer(&mut out, &board);
  println!("result: {r:?}");
  println!("bytes already written: {:?}", String::from_utf8(out).unwrap());
}

result: Err(Error("key must be a string", line: 0, column: 0))
bytes already written: "{\"name\":\"demo\",\"cells\":{"

use serde_json::json;

fn main() {
  let v = json!({ 1: "one" });
  println!("{v}");
}

error[E0277]: the trait bound `std::string::String: From<{integer}>` is not satisfied
 --> src/bin/km_json_macro.rs:4:11
  |
4 |   let v = json!({ 1: "one" });
  |           ^^^^^^^^^^^^^^^^^^^ the trait `From<{integer}>` is not implemented for `std::string::String`
  |
  = help: `std::string::String` implements trait `From<T>`:
            From<&mut str>
            From<&std::string::String>
            From<&str>
            From<Box<str>>
            From<Cow<'_, str>>
            From<char>
  = note: required for `{integer}` to implement `Into<std::string::String>`
  = note: this error originates in the macro `$crate::json_internal` which comes from the expansion of the macro `json` (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` (bin "km_json_macro") due to 1 previous error

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
        Err(key_must_be_a_string())
    }

use std::collections::{BTreeMap, HashMap};
use std::fmt;
use std::str::FromStr;

use serde::{Deserialize, Serialize};
use serde_with::{DisplayFromStr, Seq, serde_as};

// 1. map -> JSON array of [key, value] pairs
#[serde_as]
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Board {
  #[serde_as(as = "Seq<(_, _)>")]
  cells: BTreeMap<(u32, u32), char>,
}

// 2. key -> JSON string via Display / FromStr
#[derive(PartialEq, Eq, Hash, Debug)]
struct Cell {
  row: u32,
  col: u32,
}

impl fmt::Display for Cell {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{},{}", self.row, self.col)
  }
}

impl FromStr for Cell {
  type Err = String;
  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let (r, c) = s.split_once(',').ok_or_else(|| format!("no comma in {s:?}"))?;
    Ok(Cell {
      row: r.parse().map_err(|e| format!("{e}"))?,
      col: c.parse().map_err(|e| format!("{e}"))?,
    })
  }
}

#[serde_as]
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct ByCell {
  #[serde_as(as = "HashMap<DisplayFromStr, _>")]
  cells: HashMap<Cell, char>,
}

fn main() {
  let board = Board { cells: BTreeMap::from([((0, 1), 'x'), ((2, 2), 'o')]) };
  let text = serde_json::to_string(&board).unwrap();
  let back: Board = serde_json::from_str(&text).unwrap();
  println!("Seq<(_, _)>:      {text}  round trip equal: {}", back == board);

  let by_cell = ByCell { cells: HashMap::from([(Cell { row: 0, col: 1 }, 'x')]) };
  let text = serde_json::to_string(&by_cell).unwrap();
  let back: ByCell = serde_json::from_str(&text).unwrap();
  println!("DisplayFromStr:   {text}  round trip equal: {}", back == by_cell);
  println!("bad key:          {}", serde_json::from_str::<ByCell>(r#"{"cells":{"01":"x"}}"#).unwrap_err());
}

Seq<(_, _)>:      {"cells":[[[0,1],"x"],[[2,2],"o"]]}  round trip equal: true
DisplayFromStr:   {"cells":{"0,1":"x"}}  round trip equal: true
bad key:          no comma in "01" at line 1 column 14

0 cells: Ok("{\"cells\":{}}")
1 cell:  Err(Error("key must be a string", line: 0, column: 0))