JSON: Parse and Produce

# Guji has no JSON codec in its prelude, so JSON is modeled as a sum type:
# a value "is one of" these shapes (§9), rendered back by `match`.
enum Json {
    JNull
    JBool($b: Bool)
    JNum($n: Int)
    JStr($s: Str)
}

# Produce: render one Json value to compact text.
sub render($j: Json): Str {
    match $j {
        JNull     { "null" }
        JBool($b) { if $b { "true" } else { "false" } }
        JNum($n)  { "$n" }
        JStr($s)  { "\"$s\"" }
    }
}

sub main() {
    $src = '{"name":"ada","age":36}'

    # Parse: lift the two fields out with named-capture regexes (§13).
    $name = match $src ~~ /"name":"(?<v>\w+)"/ {
        Some($m) { $m<v>.unwrap_or("?") }
        None     { "?" }
    }
    $age = match $src ~~ /"age":(?<v>\d+)/ {
        Some($m) { $m<v>.unwrap_or("0").parse_int().unwrap_or(0) }
        None     { 0 }
    }

    # Build a map of typed Json values and bump the age by one.
    %doc = {"name": JStr($name), "age": JNum($age + 1)}

    # Produce: sort the keys explicitly, render each value, join.
    @parts = %doc.keys().sort().map(sub($k) {
        "\"$k\":" ~ render(%doc{$k})
    })
    print("\{" ~ @parts.join(",") ~ "}")
}

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	src := `{"name":"ada","age":36}`

	// Parse into a generic map of string -> any.
	var doc map[string]any
	if err := json.Unmarshal([]byte(src), &doc); err != nil {
		panic(err)
	}

	// JSON numbers decode as float64; bump age by one.
	doc["age"] = doc["age"].(float64) + 1

	// Produce: Marshal sorts map keys alphabetically.
	out, _ := json.Marshal(doc)
	fmt.Println(string(out))
}

(* Uses the Yojson library: opam install yojson *)
let () =
  let src = {|{"name":"ada","age":36}|} in

  (* Parse into Yojson's variant tree. *)
  let doc = Yojson.Safe.from_string src in
  let bumped =
    match doc with
    | `Assoc fields ->
        let fields =
          List.map
            (function
              | "age", `Int n -> ("age", `Int (n + 1))
              | kv -> kv)
            fields
        in
        (* Produce: sort the keys, then serialize. *)
        `Assoc (List.sort (fun (a, _) (b, _) -> compare a b) fields)
    | other -> other
  in
  print_endline (Yojson.Safe.to_string bumped)

-- Uses the aeson library: cabal install aeson
{-# LANGUAGE OverloadedStrings #-}
import Data.Aeson (Value (Number, Object), decode, encode)
import qualified Data.Aeson.KeyMap as KM
import qualified Data.ByteString.Lazy.Char8 as B

main :: IO ()
main = do
  let src = "{\"name\":\"ada\",\"age\":36}"
  -- Parse into aeson's Value tree (Maybe handles failure).
  case decode src :: Maybe Value of
    Just (Object o) -> do
      -- Bump age by one, then re-encode (aeson sorts object keys).
      let bumped = KM.adjust inc "age" o
      B.putStrLn (encode (Object bumped))
    _ -> putStrLn "parse error"
  where
    inc (Number n) = Number (n + 1)
    inc v = v

use strict;
use warnings;
use JSON::PP;

my $src = '{"name":"ada","age":36}';

# Parse: decode the JSON text into a Perl hash ref.
my $doc = decode_json($src);
$doc->{age} += 1;

# Produce: ->canonical sorts the keys for deterministic output.
my $json = JSON::PP->new->canonical;
print $json->encode($doc), "\n";

use JSON::Fast;

my $src = '{"name":"ada","age":36}';

# Parse: from-json returns a Raku Hash of native values.
my %doc = from-json($src);
%doc<age> += 1;

# Produce: :sorted-keys orders the keys, :!pretty keeps it on one line.
say to-json(%doc, :sorted-keys, :!pretty);

// Uses the serde_json crate: cargo add serde_json
use serde_json::{json, Value};

fn main() {
    let src = r#"{"name":"ada","age":36}"#;

    // Parse into an untyped serde_json Value tree.
    let mut doc: Value = serde_json::from_str(src).unwrap();

    // Bump age; as_i64 reads the number, then overwrite the field.
    let age = doc["age"].as_i64().unwrap();
    doc["age"] = json!(age + 1);

    // Produce: serde_json's default Map is a BTreeMap, so keys sort.
    println!("{}", serde_json::to_string(&doc).unwrap());
}

import json

src = '{"name":"ada","age":36}'

# Parse: a JSON string becomes a dict of native Python values.
doc = json.loads(src)
doc["age"] += 1

# Produce: sort_keys + compact separators give deterministic output.
print(json.dumps(doc, separators=(",", ":"), sort_keys=True))