#Yu-zh/data

///|
#data.derive(Serialize, Deserialize)
pub(all) struct User {
  name : String
  age : Int
}

// Works with every format, without the type mentioning any of them.

///|
let bytes = @json.to_bytes(user)

///|
let value = @data.to_value(user)

#Install

moon add Yu-zh/data

import {
  "Yu-zh/data",
  "Yu-zh/data/json",
}

#The five pieces

///|
pub(open) trait Serialize {
  fn[S : Serializer] serialize(Self, S) -> Unit raise SerError
}

///|
pub(open) trait Deserialize {
  fn[D : Deserializer] deserialize(D) -> Self raise DeError
}

#Writing an implementation

///|
pub(all) struct User {
  name : String
  age : Int
  /// An `Option` field: absent and explicitly null both read back as `None`.
  nickname : String?
} derive(Eq, Debug)

///|
pub impl @data.Serialize for User with fn serialize(self, s) {
  s.serialize_struct_begin("User", 3)
  s.serialize_field("name", self.name)
  s.serialize_field("age", self.age)
  s.serialize_field("nickname", self.nickname)
  s.serialize_struct_end()
}

///|
let user_fields : ReadOnlyArray[String] = ["name", "age", "nickname"]

///|
pub impl @data.Deserialize for User with fn deserialize(d) {
  d.deserialize_struct_begin("User", user_fields)
  let mut name = None
  let mut age = None
  let mut nickname = None
  while d.deserialize_field_name() is Some(field) {
    match field {
      "name" => name = Some(d.deserialize_field_value())
      "age" => age = Some(d.deserialize_field_value())
      "nickname" => nickname = d.deserialize_field_value()
      // Unknown fields are skipped rather than rejected.
      _ => d.skip_value()
    }
  }
  {
    name: @data.required(name, name="name", path=d.path()),
    age: @data.required(age, name="age", path=d.path()),
    nickname,
  }
}

///|
test "one implementation, every format" {
  let user = User::{ name: "ada", age: 36, nickname: None }

  // JSON, as UTF-8 bytes.
  inspect(
    @json.to_string(user),
    content="{\"name\":\"ada\",\"age\":36,\"nickname\":null}",
  )
  assert_eq((@json.from_string(@json.to_string(user)) : User), user)

  // The same value in memory, with no encoding step.
  inspect(
    @data.to_value(user),
    content="{\"name\": \"ada\", \"age\": 36, \"nickname\": null}",
  )
  assert_eq((@data.from_value(@data.to_value(user)) : User), user)
}

#Enums

///|
pub(all) enum Role {
  Guest
  Member(String)
  Admin(level~ : Int, since~ : String)
} derive(Eq, Debug)

///|
pub impl @data.Serialize for Role with fn serialize(self, s) {
  let name = "Role"
  match self {
    Guest =>
      s.serialize_unit_variant({ enum_name: name, index: 0, name: "Guest" })
    Member(team) =>
      s.serialize_newtype_variant(
        { enum_name: name, index: 1, name: "Member" },
        team,
      )
    Admin(level~, since~) => {
      s.serialize_struct_variant_begin(
        { enum_name: name, index: 2, name: "Admin" },
        2,
      )
      s.serialize_struct_variant_field("level", level)
      s.serialize_struct_variant_field("since", since)
      s.serialize_struct_variant_end()
    }
  }
}

///|
test "enums are externally tagged" {
  inspect(@json.to_string(Guest), content="\"Guest\"")
  inspect(@json.to_string(Member("core")), content="{\"Member\":\"core\"}")
  inspect(
    @json.to_string(Admin(level=2, since="2019")),
    content="{\"Admin\":{\"level\":2,\"since\":\"2019\"}}",
  )
}

#Deriving instead

///|
#data.derive(Serialize, Deserialize)
pub(all) struct Config {
  #data.rename("max-retries")
  max_retries : Int
  #data.skip
  cache_generation : Int
}

moonx Yu-zh/data/derive [path ...]

#Errors carry a path

///|
test "errors say where" {
  let bad = "[{\"name\":\"ada\",\"age\":\"thirty-six\"}]"
  try (@json.from_string(bad) : Array[User]) catch {
    e =>
      inspect(
        e,
        content="$[0].age: invalid type: expected a number, found string",
      )
  } noraise {
    _ => fail("expected a type error")
  }
}

#Untyped documents

///|
test "Value carries any document" {
  let text = "{\"tags\":[1,-2.5,true,null],\"name\":\"ada\",\"meta\":{}}"
  let value : @data.Value = @json.from_string(text)
  guard value.get("tags") is Some(tags) else { fail("expected a tags field") }
  inspect(tags, content="[1, -2.5, true, null]")
  inspect(@json.to_string(value), content=text)
  // Strings inside are UTF-8 bytes; `text()` is the explicit step to a String.
  guard value.get("name") is Some(name) else { fail("expected a name field") }
  guard name.text() is Some(who) else { fail("expected valid UTF-8") }
  inspect(who, content="ada")
}

#JSON specifics

///|
test "the transport is bytes" {
  assert_eq(@json.to_bytes("é"), b"\x22\xc3\xa9\x22")
  assert_eq((@json.from_bytes(b"[1,2]") : Array[Int]), [1, 2])
}

• NaN and infinity raise UnsupportedType instead of silently becoming null, because losing them quietly is worse than failing.
• A non-string, non-numeric map key raises instead of being coerced.

#CBOR specifics

///|
test "what CBOR carries that JSON cannot" {
  // A byte string stays bytes, rather than becoming an array of numbers.
  assert_eq(@cbor.to_bytes(b"\x01\x02"), b"\x42\x01\x02")
  // A map key need not be a string.
  let keyed : Map[Int, String] = { 1: "a" }
  assert_eq((@cbor.from_bytes(@cbor.to_bytes(keyed)) : Map[Int, String]), keyed)
  // Unsigned and negative integers are distinct major types, so a double is
  // never mistaken for an integer that happened to be whole.
  assert_eq(@cbor.to_bytes(1.5), b"\xfb\x3f\xf8\x00\x00\x00\x00\x00\x00")
}

#MessagePack specifics

///|
test "every value takes its narrowest form" {
  assert_eq(@msgpack.to_bytes(127), b"\x7f")
  assert_eq(@msgpack.to_bytes(128), b"\xcc\x80")
  assert_eq(@msgpack.to_bytes(-32), b"\xe0")
  assert_eq(@msgpack.to_bytes(b"\x01\x02"), b"\xc4\x02\x01\x02")
}

#TOML specifics

///|
test "scalars come out before sub-tables" {
  let doc : Map[String, @data.Value] = {
    "name": Str(b"prod"),
    "server": Map([(Str(b"port"), Int(8080L))]),
  }
  inspect(
    @toml.to_string(doc),
    content=(
      #|name = "prod"
      #|
      #|[server]
      #|port = 8080
      #|
    ),
  )
}

#Choosing a format

#How this differs from Rust's serde

#License