attempt to subtract with overflow，或者 [],1,2]

use serde::Serialize;
use serde::ser::{SerializeSeq, Serializer};

// Announces an empty sequence, then pushes two elements anyway.
struct Liar;

impl Serialize for Liar {
  fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    let mut seq = s.serialize_seq(Some(0))?;
    seq.serialize_element(&1)?;
    seq.serialize_element(&2)?;
    seq.end()
  }
}

fn main() {
  let s = serde_json::to_string(&Liar);
  println!("to_string        : {s:?}");
  println!("from_str back    : {:?}", serde_json::from_str::<serde_json::Value>(&s.unwrap()).map_err(|e| e.to_string()));
  println!("to_value         : {:?}", serde_json::to_value(&Liar).map(|v| v.to_string()));
  println!("to_string_pretty : {:?}", serde_json::to_string_pretty(&Liar));
}

to_string        : Ok("[],1,2]")
from_str back    : Err("trailing characters at line 1 column 3")
to_value         : Ok("[1,2]")

thread 'main' (2735112) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.154/src/ser.rs:1989:9:
attempt to subtract with overflow
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

(target/release/liar > out.txt 2>&1 & pid=$!
 for t in 1 2 3 4 5 6 7 8 9; do
   perl -e 'select(undef,undef,undef,1)'; echo "t=${t}s $(ps -o rss=,vsz=,%cpu= -p $pid)"
 done
 kill $pid; wait $pid; echo "killed exit=$?"); cat out.txt

t=1s 1063888 490879248  98.4
t=2s 2119792 492976400 100.0
t=3s 3183584 492976400 100.0
t=4s 4236624 497170704  99.0
t=5s 5277008 497170704  99.7
t=6s 6333552 497170704 100.0
t=7s 7379088 497170704 100.0
t=8s 8430304 505559312  98.3
t=9s 9477392 505559312 100.0
killed exit=143
to_string        : Ok("[],1,2]")
from_str back    : Err("trailing characters at line 1 column 3")
to_value         : Ok("[1,2]")

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
        tri!(self
            .formatter
            .begin_array(&mut self.writer)
            .map_err(Error::io));
        if len == Some(0) {
            tri!(self
                .formatter
                .end_array(&mut self.writer)
                .map_err(Error::io));
            Ok(Compound::Map {
                ser: self,
                state: State::Empty,
            })
        } else {
            // ...
        }
    }

    fn end_array<W>(&mut self, writer: &mut W) -> io::Result<()>
    where
        W: ?Sized + io::Write,
    {
        self.current_indent -= 1;

        if self.has_value {
            tri!(writer.write_all(b"\n"));
            tri!(indent(writer, self.current_indent, self.indent));
        }
        // ...
    }

use serde::Serialize;
use serde::ser::{SerializeSeq, Serializer};

// Only the even numbers are serialized, so items.len() would be a lie.
struct Evens(Vec<u32>);

// Fix 1: say None when the count is not known up front.
struct EvensNone<'a>(&'a Evens);
impl Serialize for EvensNone<'_> {
  fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    let mut seq = s.serialize_seq(None)?;
    for x in self.0.0.iter().filter(|x| *x % 2 == 0) {
      seq.serialize_element(x)?;
    }
    seq.end()
  }
}

// Fix 2: count first, then announce the exact number.
struct EvensExact<'a>(&'a Evens);
impl Serialize for EvensExact<'_> {
  fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    let n = self.0.0.iter().filter(|x| *x % 2 == 0).count();
    let mut seq = s.serialize_seq(Some(n))?;
    for x in self.0.0.iter().filter(|x| *x % 2 == 0) {
      seq.serialize_element(x)?;
    }
    seq.end()
  }
}

// Fix 3: hand the iterator to collect_seq; it computes len from size_hint.
struct EvensCollect<'a>(&'a Evens);
impl Serialize for EvensCollect<'_> {
  fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    s.collect_seq(self.0.0.iter().filter(|x| *x % 2 == 0))
  }
}

fn show<T: Serialize>(label: &str, v: &T) {
  let pretty = serde_json::to_string_pretty(v);
  let bin = bincode::serialize(v).map_err(|e| e.to_string());
  println!("{label:<8} to_string={:?} pretty={pretty:?}", serde_json::to_string(v));
  println!("{:<8} bincode={bin:?}", "");
}

fn main() {
  for items in [vec![1, 3], vec![1, 2, 3, 4]] {
    let e = Evens(items);
    println!("items = {:?}", e.0);
    show("None", &EvensNone(&e));
    show("exact", &EvensExact(&e));
    show("collect", &EvensCollect(&e));
  }
}

items = [1, 3]
None     to_string=Ok("[]") pretty=Ok("[]")
         bincode=Err("Bincode can only encode sequences and maps that have a knowable size ahead of time")
exact    to_string=Ok("[]") pretty=Ok("[]")
         bincode=Ok([0, 0, 0, 0, 0, 0, 0, 0])
collect  to_string=Ok("[]") pretty=Ok("[]")
         bincode=Err("Bincode can only encode sequences and maps that have a knowable size ahead of time")
items = [1, 2, 3, 4]
None     to_string=Ok("[2,4]") pretty=Ok("[\n  2,\n  4\n]")
         bincode=Err("Bincode can only encode sequences and maps that have a knowable size ahead of time")
exact    to_string=Ok("[2,4]") pretty=Ok("[\n  2,\n  4\n]")
         bincode=Ok([2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0])
collect  to_string=Ok("[2,4]") pretty=Ok("[\n  2,\n  4\n]")
         bincode=Err("Bincode can only encode sequences and maps that have a knowable size ahead of time")