escape

doc/tutorial.md

···
 ```ocaml
 # open Jsont_pointer;;
 # #install_printer Jsont_pointer_top.printer;;
+# #install_printer Jsont_pointer_top.json_printer;;
 # let parse_json s =
     match Jsont_bytesrw.decode_string Jsont.json s with
     | Ok json -> json
     | Error e -> failwith e;;
 val parse_json : string -> Jsont.json = <fun>
-# let json_to_string json =
-    match Jsont_bytesrw.encode_string ~format:Jsont.Minify Jsont.json json with
-    | Ok s -> s
-    | Error e -> failwith e;;
-val json_to_string : Jsont.json -> string = <fun>
 ```
 
 ## What is JSON Pointer?
···
     ]
   }|};;
 val users_json : Jsont.json =
-  Jsont.Object
-   ([(("users", <abstr>),
-      Jsont.Array
-       ([Jsont.Object
-          ([(("name", <abstr>), Jsont.String ("Alice", <abstr>));
-            (("age", <abstr>), Jsont.Number (30., <abstr>))],
-           <abstr>);
-         Jsont.Object
-          ([(("name", <abstr>), Jsont.String ("Bob", <abstr>));
-            (("age", <abstr>), Jsont.Number (25., <abstr>))],
-           <abstr>)],
-        <abstr>))],
-    <abstr>)
+  {"users":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}
 ```
 
 The JSON Pointer `/users/0/name` refers to the string `"Alice"`:
···
 # let ptr = of_string "/users/0/name";;
 val ptr : t = [`Mem "users"; `Nth 0; `Mem "name"]
 # get ptr users_json;;
-- : Jsont.json = Jsont.String ("Alice", <abstr>)
+- : Jsont.json = "Alice"
 ```
 
 In OCaml, this is represented by the `Jsont_pointer.t` type - a sequence
···
     "m~n": 8
   }|};;
 val rfc_example : Jsont.json =
-  Jsont.Object
-   ([(("foo", <abstr>),
-      Jsont.Array
-       ([Jsont.String ("bar", <abstr>); Jsont.String ("baz", <abstr>)],
-        <abstr>));
-     (("", <abstr>), Jsont.Number (0., <abstr>));
-     (("a/b", <abstr>), Jsont.Number (1., <abstr>));
-     (("c%d", <abstr>), Jsont.Number (2., <abstr>));
-     (("e^f", <abstr>), Jsont.Number (3., <abstr>));
-     (("g|h", <abstr>), Jsont.Number (4., <abstr>));
-     (("i\\j", <abstr>), Jsont.Number (5., <abstr>));
-     (("k\"l", <abstr>), Jsont.Number (6., <abstr>));
-     ((" ", <abstr>), Jsont.Number (7., <abstr>));
-     (("m~n", <abstr>), Jsont.Number (8., <abstr>))],
-    <abstr>)
+  {"foo":["bar","baz"],"":0,"a/b":1,"c%d":2,"e^f":3,"g|h":4,"i\\j":5,"k\"l":6," ":7,"m~n":8}
 ```
 
 This document is carefully constructed to exercise various edge cases!
···
 ### The Root Pointer
 
 ```ocaml
-# get root rfc_example |> json_to_string;;
-- : string =
-"{\"foo\":[\"bar\",\"baz\"],\"\":0,\"a/b\":1,\"c%d\":2,\"e^f\":3,\"g|h\":4,\"i\\\\j\":5,\"k\\\"l\":6,\" \":7,\"m~n\":8}"
+# get root rfc_example ;;
+- : Jsont.json =
+{"foo":["bar","baz"],"":0,"a/b":1,"c%d":2,"e^f":3,"g|h":4,"i\\j":5,"k\"l":6," ":7,"m~n":8}
 ```
 
 The empty pointer (`root`) returns the whole document.
···
 ### Object Member Access
 
 ```ocaml
-# get (of_string "/foo") rfc_example |> json_to_string;;
-- : string = "[\"bar\",\"baz\"]"
+# get (of_string "/foo") rfc_example ;;
+- : Jsont.json = ["bar","baz"]
 ```
 
 `/foo` accesses the member named `foo`, which is an array.
···
 ### Array Index Access
 
 ```ocaml
-# get (of_string "/foo/0") rfc_example |> json_to_string;;
-- : string = "\"bar\""
-# get (of_string "/foo/1") rfc_example |> json_to_string;;
-- : string = "\"baz\""
+# get (of_string "/foo/0") rfc_example ;;
+- : Jsont.json = "bar"
+# get (of_string "/foo/1") rfc_example ;;
+- : Jsont.json = "baz"
 ```
 
 `/foo/0` first goes to `foo`, then accesses index 0 of the array.
···
 JSON allows empty strings as object keys:
 
 ```ocaml
-# get (of_string "/") rfc_example |> json_to_string;;
-- : string = "0"
+# get (of_string "/") rfc_example ;;
+- : Jsont.json = 0
 ```
 
 The pointer `/` has one token: the empty string. This accesses the member
···
 The RFC example includes keys with `/` and `~` characters:
 
 ```ocaml
-# get (of_string "/a~1b") rfc_example |> json_to_string;;
-- : string = "1"
+# get (of_string "/a~1b") rfc_example ;;
+- : Jsont.json = 1
 ```
 
 The token `a~1b` refers to the key `a/b`. We'll explain this escaping
 [below](#escaping-special-characters).
 
 ```ocaml
-# get (of_string "/m~0n") rfc_example |> json_to_string;;
-- : string = "8"
+# get (of_string "/m~0n") rfc_example ;;
+- : Jsont.json = 8
 ```
 
 The token `m~0n` refers to the key `m~n`.
···
 val slash_ptr : t = [`Mem "a/b"]
 # to_string slash_ptr;;
 - : string = "/a~1b"
-# get slash_ptr rfc_example |> json_to_string;;
-- : string = "1"
+# get slash_ptr rfc_example ;;
+- : Jsont.json = 1
 ```
 
 The library escapes it when converting to string.
···
 Most characters don't need escaping in JSON Pointer strings:
 
 ```ocaml
-# get (of_string "/c%d") rfc_example |> json_to_string;;
-- : string = "2"
-# get (of_string "/e^f") rfc_example |> json_to_string;;
-- : string = "3"
-# get (of_string "/g|h") rfc_example |> json_to_string;;
-- : string = "4"
-# get (of_string "/ ") rfc_example |> json_to_string;;
-- : string = "7"
+# get (of_string "/c%d") rfc_example ;;
+- : Jsont.json = 2
+# get (of_string "/e^f") rfc_example ;;
+- : Jsont.json = 3
+# get (of_string "/g|h") rfc_example ;;
+- : Jsont.json = 4
+# get (of_string "/ ") rfc_example ;;
+- : Jsont.json = 7
 ```
 
 Even a space is a valid key character!
···
 
 ```ocaml
 # let obj = parse_json {|{"foo":"bar"}|};;
-val obj : Jsont.json =
-  Jsont.Object ([(("foo", <abstr>), Jsont.String ("bar", <abstr>))], <abstr>)
+val obj : Jsont.json = {"foo":"bar"}
 # add (of_string "/baz") obj ~value:(Jsont.Json.string "qux")
-  |> json_to_string;;
-- : string = "{\"foo\":\"bar\",\"baz\":\"qux\"}"
+  ;;
+- : Jsont.json = {"foo":"bar","baz":"qux"}
 ```
 
 For arrays, `add` inserts BEFORE the specified index:
 
 ```ocaml
 # let arr_obj = parse_json {|{"foo":["a","b"]}|};;
-val arr_obj : Jsont.json =
-  Jsont.Object
-   ([(("foo", <abstr>),
-      Jsont.Array
-       ([Jsont.String ("a", <abstr>); Jsont.String ("b", <abstr>)], <abstr>))],
-    <abstr>)
+val arr_obj : Jsont.json = {"foo":["a","b"]}
 # add (of_string "/foo/1") arr_obj ~value:(Jsont.Json.string "X")
-  |> json_to_string;;
-- : string = "{\"foo\":[\"a\",\"X\",\"b\"]}"
+  ;;
+- : Jsont.json = {"foo":["a","X","b"]}
 ```
 
 This is where the `-` marker shines - it appends to the end:
 
 ```ocaml
 # add (of_string "/foo/-") arr_obj ~value:(Jsont.Json.string "c")
-  |> json_to_string;;
-- : string = "{\"foo\":[\"a\",\"b\",\"c\"]}"
+  ;;
+- : Jsont.json = {"foo":["a","b","c"]}
 ```
 
 ### Remove
···
 
 ```ocaml
 # let two_fields = parse_json {|{"foo":"bar","baz":"qux"}|};;
-val two_fields : Jsont.json =
-  Jsont.Object
-   ([(("foo", <abstr>), Jsont.String ("bar", <abstr>));
-     (("baz", <abstr>), Jsont.String ("qux", <abstr>))],
-    <abstr>)
-# remove (of_string "/baz") two_fields |> json_to_string;;
-- : string = "{\"foo\":\"bar\"}"
+val two_fields : Jsont.json = {"foo":"bar","baz":"qux"}
+# remove (of_string "/baz") two_fields ;;
+- : Jsont.json = {"foo":"bar"}
 ```
 
 For arrays, it removes and shifts:
 
 ```ocaml
 # let three_elem = parse_json {|{"foo":["a","b","c"]}|};;
-val three_elem : Jsont.json =
-  Jsont.Object
-   ([(("foo", <abstr>),
-      Jsont.Array
-       ([Jsont.String ("a", <abstr>); Jsont.String ("b", <abstr>);
-         Jsont.String ("c", <abstr>)],
-        <abstr>))],
-    <abstr>)
-# remove (of_string "/foo/1") three_elem |> json_to_string;;
-- : string = "{\"foo\":[\"a\",\"c\"]}"
+val three_elem : Jsont.json = {"foo":["a","b","c"]}
+# remove (of_string "/foo/1") three_elem ;;
+- : Jsont.json = {"foo":["a","c"]}
 ```
 
 ### Replace
···
 
 ```ocaml
 # replace (of_string "/foo") obj ~value:(Jsont.Json.string "baz")
-  |> json_to_string;;
-- : string = "{\"foo\":\"baz\"}"
+  ;;
+- : Jsont.json = {"foo":"baz"}
 ```
 
 Unlike `add`, `replace` requires the target to already exist.
···
 
 ```ocaml
 # let nested = parse_json {|{"foo":{"bar":"baz"},"qux":{}}|};;
-val nested : Jsont.json =
-  Jsont.Object
-   ([(("foo", <abstr>),
-      Jsont.Object
-       ([(("bar", <abstr>), Jsont.String ("baz", <abstr>))], <abstr>));
-     (("qux", <abstr>), Jsont.Object ([], <abstr>))],
-    <abstr>)
+val nested : Jsont.json = {"foo":{"bar":"baz"},"qux":{}}
 # move ~from:(of_string "/foo/bar") ~path:(of_string "/qux/thud") nested
-  |> json_to_string;;
-- : string = "{\"foo\":{},\"qux\":{\"thud\":\"baz\"}}"
+  ;;
+- : Jsont.json = {"foo":{},"qux":{"thud":"baz"}}
 ```
 
 ### Copy
···
 
 ```ocaml
 # let to_copy = parse_json {|{"foo":{"bar":"baz"}}|};;
-val to_copy : Jsont.json =
-  Jsont.Object
-   ([(("foo", <abstr>),
-      Jsont.Object
-       ([(("bar", <abstr>), Jsont.String ("baz", <abstr>))], <abstr>))],
-    <abstr>)
+val to_copy : Jsont.json = {"foo":{"bar":"baz"}}
 # copy ~from:(of_string "/foo/bar") ~path:(of_string "/foo/qux") to_copy
-  |> json_to_string;;
-- : string = "{\"foo\":{\"bar\":\"baz\",\"qux\":\"baz\"}}"
+  ;;
+- : Jsont.json = {"foo":{"bar":"baz","qux":"baz"}}
 ```
 
 ### Test
···
     "features": ["auth", "logging", "metrics"]
   }|};;
 val config_json : Jsont.json =
-  Jsont.Object
-   ([(("database", <abstr>),
-      Jsont.Object
-       ([(("host", <abstr>), Jsont.String ("localhost", <abstr>));
-         (("port", <abstr>), Jsont.Number (5432., <abstr>));
-         (("credentials", <abstr>),
-          Jsont.Object
-           ([(("username", <abstr>), Jsont.String ("admin", <abstr>));
-             (("password", <abstr>), Jsont.String ("secret", <abstr>))],
-            <abstr>))],
-        <abstr>));
-     (("features", <abstr>),
-      Jsont.Array
-       ([Jsont.String ("auth", <abstr>); Jsont.String ("logging", <abstr>);
-         Jsont.String ("metrics", <abstr>)],
-        <abstr>))],
-    <abstr>)
+  {"database":{"host":"localhost","port":5432,"credentials":{"username":"admin","password":"secret"}},"features":["auth","logging","metrics"]}
 ```
 
 ### Typed Access with `path`
···
     }
   }|};;
 val org_json : Jsont.json =
-  Jsont.Object
-   ([(("organization", <abstr>),
-      Jsont.Object
-       ([(("owner", <abstr>),
-          Jsont.Object
-           ([(("name", <abstr>), Jsont.String ("Alice", <abstr>));
-             (("email", <abstr>),
-              Jsont.String ("[e-mail]", <abstr>));
-             (("age", <abstr>), Jsont.Number (35., <abstr>))],
-            <abstr>));
-         (("members", <abstr>),
-          Jsont.Array
-           ([Jsont.Object
-              ([(("name", <abstr>), Jsont.String ("Bob", <abstr>));
-                (("email", <abstr>),
-                 Jsont.String ("[e-mail]", <abstr>));
-                (("age", <abstr>), Jsont.Number (28., <abstr>))],
-               <abstr>)],
-            <abstr>))],
-        <abstr>))],
-    <abstr>)
+  {"organization":{"owner":{"name":"Alice","email":"[e-mail]","age":35},"members":[{"name":"Bob","email":"[e-mail]","age":28}]}}
 # Jsont.Json.decode
     (path (of_string "/organization/owner/name") Jsont.string)
     org_json

src/jsont_pointer.ml

···
 
 let pp_verbose ppf p =
   let pp_index ppf = function
-    | `Mem s -> Format.fprintf ppf "`Mem %S" s
+    | `Mem s -> Format.fprintf ppf {|`Mem "%s"|} s
     | `Nth n -> Format.fprintf ppf "`Nth %d" n
     | `End -> Format.fprintf ppf "`End"
   in