simplify

bin/jsonpp.ml

···
     let indices = Jsont_pointer.indices p in
     let index_strs = List.map (fun idx ->
       match idx with
-      | Jsont_pointer.Index.Mem s -> Printf.sprintf "Mem:%s" s
-      | Jsont_pointer.Index.Nth n -> Printf.sprintf "Nth:%d" n
-      | Jsont_pointer.Index.End -> "End"
+      | `Mem s -> Printf.sprintf "Mem:%s" s
+      | `Nth n -> Printf.sprintf "Nth:%d" n
+      | `End -> "End"
     ) indices in
     Printf.printf "OK: [%s]\n" (String.concat ", " index_strs)
   with Jsont.Error e ->

doc/dune

···
 (mdx
- (deps
-  %{bin:jsonpp}
-  rfc6901_example.json
-  config.json)
  (libraries jsont jsont.bytesrw jsont_pointer))

doc/tutorial.md

···
 [RFC 6901](https://www.rfc-editor.org/rfc/rfc6901), and demonstrates
 the `jsont-pointer` OCaml library through interactive examples.
 
+## Setup
+
+First, let's set up our environment with helper functions:
+
+```ocaml
+# open Jsont_pointer;;
+# 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>
+# let show_pointer p =
+    let idxs = indices p in
+    let show_index = function
+      | `Mem s -> "Mem:" ^ s
+      | `Nth n -> "Nth:" ^ string_of_int n
+      | `End -> "End"
+    in
+    "[" ^ String.concat ", " (List.map show_index idxs) ^ "]";;
+val show_pointer : t -> string = <fun>
+```
+
 ## What is JSON Pointer?
 
 From RFC 6901, Section 1:
···
 
 For example, given this JSON document:
 
-```json
-{
-  "users": [
-    {"name": "Alice", "age": 30},
-    {"name": "Bob", "age": 25}
-  ]
-}
+```ocaml
+# let users_json = parse_json {|{
+    "users": [
+      {"name": "Alice", "age": 30},
+      {"name": "Bob", "age": 25}
+    ]
+  }|};;
+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>)
 ```
 
-The JSON Pointer `/users/0/name` refers to the string `"Alice"`.
+The JSON Pointer `/users/0/name` refers to the string `"Alice"`:
+
+```ocaml
+# let ptr = of_string "/users/0/name";;
+val ptr : t = <abstr>
+# get ptr users_json;;
+- : Jsont.json = Jsont.String ("Alice", <abstr>)
+```
 
 In OCaml, this is represented by the `Jsont_pointer.t` type - a sequence
 of navigation steps from the document root to a target value.
···
 - Every non-empty pointer starts with `/`
 - Everything between `/` characters is a "reference token"
 
-Let's see this in action. We can parse pointers and see their structure:
+Let's see this in action:
 
-```sh
-$ jsonpp parse ""
-OK: []
+```ocaml
+# let empty_ptr = of_string "";;
+val empty_ptr : t = <abstr>
+# show_pointer empty_ptr;;
+- : string = "[]"
 ```
 
 The empty pointer has no reference tokens - it points to the root.
 
-```sh
-$ jsonpp parse "/foo"
-OK: [Mem:foo]
+```ocaml
+# let foo_ptr = of_string "/foo";;
+val foo_ptr : t = <abstr>
+# show_pointer foo_ptr;;
+- : string = "[Mem:foo]"
 ```
 
 The pointer `/foo` has one token: `foo`. Since it's not a number, it's
 interpreted as an object member name (`Mem`).
 
-```sh
-$ jsonpp parse "/foo/0"
-OK: [Mem:foo, Nth:0]
+```ocaml
+# let foo_0_ptr = of_string "/foo/0";;
+val foo_0_ptr : t = <abstr>
+# show_pointer foo_0_ptr;;
+- : string = "[Mem:foo, Nth:0]"
 ```
 
 Here we have two tokens: `foo` (a member name) and `0` (interpreted as
 an array index `Nth`).
 
-```sh
-$ jsonpp parse "/foo/bar/baz"
-OK: [Mem:foo, Mem:bar, Mem:baz]
+```ocaml
+# show_pointer (of_string "/foo/bar/baz");;
+- : string = "[Mem:foo, Mem:bar, Mem:baz]"
 ```
 
 Multiple tokens navigate deeper into nested structures.
···
 
 <!-- $MDX skip -->
 ```ocaml
-type t =
-  | Mem of string   (* Object member access *)
-  | Nth of int      (* Array index access *)
-  | End             (* The special "-" marker for append operations *)
+type t = [
+  | `Mem of string   (* Object member access *)
+  | `Nth of int      (* Array index access *)
+  | `End             (* The special "-" marker for append operations *)
+]
 ```
 
 The `Mem` variant holds the **unescaped** member name - you work with the
···
 
 What happens if a pointer doesn't start with `/`?
 
-```sh
-$ jsonpp parse "foo"
-ERROR: Invalid JSON Pointer: must be empty or start with '/': foo
+```ocaml
+# of_string "foo";;
+Exception: Jsont.Error ([], <abstr>, <abstr>).
 ```
 
 The RFC is strict: non-empty pointers MUST start with `/`.
 
+For safer parsing, use `of_string_result`:
+
+```ocaml
+# of_string_result "foo";;
+- : (t, string) result =
+Error "Invalid JSON Pointer: must be empty or start with '/': foo"
+# of_string_result "/valid";;
+- : (t, string) result = Ok <abstr>
+```
+
 ## Evaluation: Navigating JSON
 
 Now we come to the heart of JSON Pointer: evaluation. RFC 6901, Section 4
···
 > the document. Each reference token in the JSON Pointer is evaluated
 > sequentially.
 
-In the library, this is the `Jsont_pointer.get` function:
+Let's use the example JSON document from RFC 6901, Section 5:
 
-<!-- $MDX skip -->
 ```ocaml
-val get : t -> Jsont.json -> Jsont.json
-```
-
-Let's use the example JSON document from RFC 6901, Section 5:
-
-```sh
-$ cat rfc6901_example.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
-}
+# let rfc_example = parse_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
+  }|};;
+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>)
 ```
 
 This document is carefully constructed to exercise various edge cases!
 
 ### The Root Pointer
 
-```sh
-$ jsonpp eval rfc6901_example.json ""
-OK: {"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 returns the whole document. In OCaml, this is
-`Jsont_pointer.root`:
-
-<!-- $MDX skip -->
 ```ocaml
-val root : t
-(** The empty pointer that references the whole document. *)
+# 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}"
 ```
 
+The empty pointer (`root`) returns the whole document.
+
 ### Object Member Access
 
-```sh
-$ jsonpp eval rfc6901_example.json "/foo"
-OK: ["bar","baz"]
+```ocaml
+# get (of_string "/foo") rfc_example |> json_to_string;;
+- : string = "[\"bar\",\"baz\"]"
 ```
 
 `/foo` accesses the member named `foo`, which is an array.
 
 ### Array Index Access
 
-```sh
-$ jsonpp eval rfc6901_example.json "/foo/0"
-OK: "bar"
+```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\""
 ```
 
 `/foo/0` first goes to `foo`, then accesses index 0 of the array.
 
-```sh
-$ jsonpp eval rfc6901_example.json "/foo/1"
-OK: "baz"
-```
-
-Index 1 gives us the second element.
-
 ### Empty String as Key
 
 JSON allows empty strings as object keys:
 
-```sh
-$ jsonpp eval rfc6901_example.json "/"
-OK: 0
+```ocaml
+# get (of_string "/") rfc_example |> json_to_string;;
+- : string = "0"
 ```
 
 The pointer `/` has one token: the empty string. This accesses the member
···
 
 The RFC example includes keys with `/` and `~` characters:
 
-```sh
-$ jsonpp eval rfc6901_example.json "/a~1b"
-OK: 1
+```ocaml
+# get (of_string "/a~1b") rfc_example |> json_to_string;;
+- : string = "1"
 ```
 
 The token `a~1b` refers to the key `a/b`. We'll explain this escaping
 [below](#escaping-special-characters).
 
-```sh
-$ jsonpp eval rfc6901_example.json "/m~0n"
-OK: 8
+```ocaml
+# get (of_string "/m~0n") rfc_example |> json_to_string;;
+- : string = "8"
 ```
 
 The token `m~0n` refers to the key `m~n`.
 
 **Important**: When using the OCaml library programmatically, you don't need
-to worry about escaping. The `Index.Mem` variant holds the literal key name:
+to worry about escaping. The `Mem` variant holds the literal key name:
 
-<!-- $MDX skip -->
 ```ocaml
-(* To access the key "a/b", just use the literal string *)
-let pointer = Jsont_pointer.make [Mem "a/b"]
+# let slash_ptr = make [`Mem "a/b"];;
+val slash_ptr : t = <abstr>
+# to_string slash_ptr;;
+- : string = "/a~1b"
+# get slash_ptr rfc_example |> json_to_string;;
+- : string = "1"
+```
 
-(* The library escapes it when converting to string *)
-let s = Jsont_pointer.to_string pointer  (* "/a~1b" *)
-```
+The library escapes it when converting to string.
 
 ### Other Special Characters (No Escaping Needed)
 
 Most characters don't need escaping in JSON Pointer strings:
 
-```sh
-$ jsonpp eval rfc6901_example.json "/c%d"
-OK: 2
-```
-
-```sh
-$ jsonpp eval rfc6901_example.json "/e^f"
-OK: 3
-```
-
-```sh
-$ jsonpp eval rfc6901_example.json "/g|h"
-OK: 4
-```
-
-```sh
-$ jsonpp eval rfc6901_example.json "/ "
-OK: 7
+```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"
 ```
 
 Even a space is a valid key character!
···
 
 What happens when we try to access something that doesn't exist?
 
-```sh
-$ jsonpp eval rfc6901_example.json "/nonexistent"
-ERROR: JSON Pointer: member 'nonexistent' not found
-File "-":
+```ocaml
+# get_result (of_string "/nonexistent") rfc_example;;
+- : (Jsont.json, Jsont.Error.t) result = Error ([], <abstr>, <abstr>)
+# find (of_string "/nonexistent") rfc_example;;
+- : Jsont.json option = None
 ```
 
 Or an out-of-bounds array index:
 
-```sh
-$ jsonpp eval rfc6901_example.json "/foo/99"
-ERROR: JSON Pointer: index 99 out of bounds (array has 2 elements)
-File "-":
+```ocaml
+# find (of_string "/foo/99") rfc_example;;
+- : Jsont.json option = None
 ```
 
 Or try to index into a non-container:
 
-```sh
-$ jsonpp eval rfc6901_example.json "/foo/0/invalid"
-ERROR: JSON Pointer: cannot index into string with 'invalid'
-File "-":
+```ocaml
+# find (of_string "/foo/0/invalid") rfc_example;;
+- : Jsont.json option = None
 ```
 
 The library provides both exception-raising and result-returning variants:
···
 
 > note that leading zeros are not allowed
 
-```sh
-$ jsonpp parse "/foo/0"
-OK: [Mem:foo, Nth:0]
+```ocaml
+# show_pointer (of_string "/foo/0");;
+- : string = "[Mem:foo, Nth:0]"
 ```
 
 Zero itself is fine.
 
-```sh
-$ jsonpp parse "/foo/01"
-OK: [Mem:foo, Mem:01]
+```ocaml
+# show_pointer (of_string "/foo/01");;
+- : string = "[Mem:foo, Mem:01]"
 ```
 
 But `01` has a leading zero, so it's NOT treated as an array index - it
···
 This is primarily useful for JSON Patch operations (RFC 6902). Let's see
 how it parses:
 
-```sh
-$ jsonpp parse "/foo/-"
-OK: [Mem:foo, End]
+```ocaml
+# show_pointer (of_string "/foo/-");;
+- : string = "[Mem:foo, End]"
 ```
 
 The `-` is recognized as a special `End` index.
···
 However, you cannot evaluate a pointer containing `-` because it refers
 to a position that doesn't exist:
 
-```sh
-$ jsonpp eval rfc6901_example.json "/foo/-"
-ERROR: JSON Pointer: '-' (end marker) refers to nonexistent array element
-File "-":
+```ocaml
+# find (of_string "/foo/-") rfc_example;;
+- : Jsont.json option = None
 ```
 
 The RFC explains this:
···
 
 The `add` operation inserts a value at a location:
 
-```sh
-$ jsonpp add '{"foo":"bar"}' '/baz' '"qux"'
-{"foo":"bar","baz":"qux"}
-```
-
-In OCaml:
-
-<!-- $MDX skip -->
 ```ocaml
-val add : t -> Jsont.json -> value:Jsont.json -> Jsont.json
+# let obj = parse_json {|{"foo":"bar"}|};;
+val obj : Jsont.json =
+  Jsont.Object ([(("foo", <abstr>), Jsont.String ("bar", <abstr>))], <abstr>)
+# add (of_string "/baz") obj ~value:(Jsont.Json.string "qux")
+  |> json_to_string;;
+- : string = "{\"foo\":\"bar\",\"baz\":\"qux\"}"
 ```
 
 For arrays, `add` inserts BEFORE the specified index:
 
-```sh
-$ jsonpp add '{"foo":["a","b"]}' '/foo/1' '"X"'
-{"foo":["a","X","b"]}
+```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>)
+# add (of_string "/foo/1") arr_obj ~value:(Jsont.Json.string "X")
+  |> json_to_string;;
+- : string = "{\"foo\":[\"a\",\"X\",\"b\"]}"
 ```
 
 This is where the `-` marker shines - it appends to the end:
 
-```sh
-$ jsonpp add '{"foo":["a","b"]}' '/foo/-' '"c"'
-{"foo":["a","b","c"]}
+```ocaml
+# add (of_string "/foo/-") arr_obj ~value:(Jsont.Json.string "c")
+  |> json_to_string;;
+- : string = "{\"foo\":[\"a\",\"b\",\"c\"]}"
 ```
 
 ### Remove
 
 The `remove` operation deletes a value:
 
-```sh
-$ jsonpp remove '{"foo":"bar","baz":"qux"}' '/baz'
-{"foo":"bar"}
+```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\"}"
 ```
 
 For arrays, it removes and shifts:
 
-```sh
-$ jsonpp remove '{"foo":["a","b","c"]}' '/foo/1'
-{"foo":["a","c"]}
+```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\"]}"
 ```
 
 ### Replace
 
 The `replace` operation updates an existing value:
 
-```sh
-$ jsonpp replace '{"foo":"bar"}' '/foo' '"baz"'
-{"foo":"baz"}
+```ocaml
+# replace (of_string "/foo") obj ~value:(Jsont.Json.string "baz")
+  |> json_to_string;;
+- : string = "{\"foo\":\"baz\"}"
 ```
 
-Unlike `add`, `replace` requires the target to already exist:
-
-```sh
-$ jsonpp replace '{"foo":"bar"}' '/nonexistent' '"value"'
-ERROR: JSON Pointer: member 'nonexistent' not found
-File "-":
-```
+Unlike `add`, `replace` requires the target to already exist.
+Attempting to replace a nonexistent path raises an error.
 
 ### Move
 
 The `move` operation relocates a value:
 
-```sh
-$ jsonpp move '{"foo":{"bar":"baz"},"qux":{}}' '/foo/bar' '/qux/thud'
-{"foo":{},"qux":{"thud":"baz"}}
+```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>)
+# move ~from:(of_string "/foo/bar") ~path:(of_string "/qux/thud") nested
+  |> json_to_string;;
+- : string = "{\"foo\":{},\"qux\":{\"thud\":\"baz\"}}"
 ```
 
 ### Copy
 
 The `copy` operation duplicates a value:
 
-```sh
-$ jsonpp copy '{"foo":{"bar":"baz"}}' '/foo/bar' '/foo/qux'
-{"foo":{"bar":"baz","qux":"baz"}}
+```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>)
+# copy ~from:(of_string "/foo/bar") ~path:(of_string "/foo/qux") to_copy
+  |> json_to_string;;
+- : string = "{\"foo\":{\"bar\":\"baz\",\"qux\":\"baz\"}}"
 ```
 
 ### Test
 
 The `test` operation verifies a value (useful in JSON Patch):
 
-```sh
-$ jsonpp test '{"foo":"bar"}' '/foo' '"bar"'
-true
-```
-
-```sh
-$ jsonpp test '{"foo":"bar"}' '/foo' '"baz"'
-false
+```ocaml
+# test (of_string "/foo") obj ~expected:(Jsont.Json.string "bar");;
+- : bool = true
+# test (of_string "/foo") obj ~expected:(Jsont.Json.string "wrong");;
+- : bool = false
 ```
 
 ## Escaping Special Characters
···
 ### The Library Handles Escaping Automatically
 
 **Important**: When using `jsont-pointer` programmatically, you rarely need
-to think about escaping. The `Index.Mem` variant stores unescaped strings,
+to think about escaping. The `Mem` variant stores unescaped strings,
 and escaping happens automatically during serialization:
 
-<!-- $MDX skip -->
 ```ocaml
-(* Create a pointer to key "a/b" - no escaping needed *)
-let p = Jsont_pointer.make [Mem "a/b"]
-
-(* Serialize to string - escaping happens automatically *)
-let s = Jsont_pointer.to_string p  (* Returns "/a~1b" *)
-
-(* Parse from string - unescaping happens automatically *)
-let p' = Jsont_pointer.of_string "/a~1b"
-(* p' contains [Mem "a/b"] - the unescaped key *)
-```
-
-The `Token` module exposes the escaping functions if you need them:
-
-<!-- $MDX skip -->
-```ocaml
-module Token : sig
-  val escape : string -> string    (* "a/b" -> "a~1b" *)
-  val unescape : string -> string  (* "a~1b" -> "a/b" *)
-end
+# let p = make [`Mem "a/b"];;
+val p : t = <abstr>
+# to_string p;;
+- : string = "/a~1b"
+# let p' = of_string "/a~1b";;
+val p' : t = <abstr>
+# show_pointer p';;
+- : string = "[Mem:a/b]"
 ```
 
 ### Escaping in Action
 
-Let's see escaping with the CLI tool:
-
-```sh
-$ jsonpp escape "hello"
-hello
-```
-
-No special characters, no escaping needed.
-
-```sh
-$ jsonpp escape "a/b"
-a~1b
-```
+The `Token` module exposes the escaping functions:
 
-The `/` becomes `~1`.
-
-```sh
-$ jsonpp escape "a~b"
-a~0b
+```ocaml
+# Token.escape "hello";;
+- : string = "hello"
+# Token.escape "a/b";;
+- : string = "a~1b"
+# Token.escape "a~b";;
+- : string = "a~0b"
+# Token.escape "~/";;
+- : string = "~0~1"
 ```
 
-The `~` becomes `~0`.
-
-```sh
-$ jsonpp escape "~/"
-~0~1
-```
-
-Both characters are escaped.
-
 ### Unescaping
 
 And the reverse process:
 
-```sh
-$ jsonpp unescape "a~1b"
-OK: a/b
-```
-
-```sh
-$ jsonpp unescape "a~0b"
-OK: a~b
+```ocaml
+# Token.unescape "a~1b";;
+- : string = "a/b"
+# Token.unescape "a~0b";;
+- : string = "a~b"
 ```
 
 ### The Order Matters!
···
 
 Let's verify this tricky case:
 
-```sh
-$ jsonpp unescape "~01"
-OK: ~1
+```ocaml
+# Token.unescape "~01";;
+- : string = "~1"
 ```
 
 If we unescaped `~0` first, `~01` would become `~1`, which would then become
 `/`. But that's wrong! The sequence `~01` should become the literal string
 `~1` (a tilde followed by the digit one).
 
-Invalid escape sequences are rejected:
-
-```sh
-$ jsonpp unescape "~2"
-ERROR: Invalid JSON Pointer: invalid escape sequence ~2
-```
-
-```sh
-$ jsonpp unescape "hello~"
-ERROR: Invalid JSON Pointer: incomplete escape sequence at end
-```
-
 ## URI Fragment Encoding
 
 JSON Pointers can be embedded in URIs. RFC 6901, Section 6 explains:
···
 
 This adds percent-encoding on top of the `~0`/`~1` escaping:
 
-```sh
-$ jsonpp uri-fragment "/foo"
-OK: /foo -> /foo
+```ocaml
+# to_uri_fragment (of_string "/foo");;
+- : string = "/foo"
+# to_uri_fragment (of_string "/a~1b");;
+- : string = "/a~1b"
+# to_uri_fragment (of_string "/c%d");;
+- : string = "/c%25d"
+# to_uri_fragment (of_string "/ ");;
+- : string = "/%20"
 ```
 
-Simple pointers often don't need percent-encoding.
-
-```sh
-$ jsonpp uri-fragment "/a~1b"
-OK: /a~1b -> /a~1b
-```
-
-The `~1` escape stays as-is (it's valid in URI fragments).
-
-```sh
-$ jsonpp uri-fragment "/c%d"
-OK: /c%d -> /c%25d
-```
-
-The `%` character must be percent-encoded as `%25` in URIs!
-
-```sh
-$ jsonpp uri-fragment "/ "
-OK: /  -> /%20
-```
-
-Spaces become `%20`.
-
-The library provides functions for URI fragment encoding:
-
-<!-- $MDX skip -->
-```ocaml
-val to_uri_fragment : t -> string
-val of_uri_fragment : string -> t
-val jsont_uri_fragment : t Jsont.t
-```
+The `%` character must be percent-encoded as `%25` in URIs, and
+spaces become `%20`.
 
 Here's the RFC example showing the URI fragment forms:
 
···
 | `"/ "`      | `#/%20`     | `7` |
 | `"/m~0n"`   | `#/m~0n`    | `8` |
 
-## Deeply Nested Structures
+## Building Pointers Programmatically
 
-JSON Pointer handles arbitrarily deep nesting:
+Instead of parsing strings, you can build pointers from indices:
 
-```sh
-$ jsonpp eval rfc6901_example.json "/foo/0"
-OK: "bar"
+```ocaml
+# let port_ptr = make [`Mem "database"; `Mem "port"];;
+val port_ptr : t = <abstr>
+# to_string port_ptr;;
+- : string = "/database/port"
 ```
 
-For deeper structures, just add more path segments. With nested objects:
+For array access, use `Nth`:
 
-```sh
-$ jsonpp add '{"a":{"b":{"c":"d"}}}' '/a/b/x' '"y"'
-{"a":{"b":{"c":"d","x":"y"}}}
+```ocaml
+# let first_feature_ptr = make [`Mem "features"; `Nth 0];;
+val first_feature_ptr : t = <abstr>
+# to_string first_feature_ptr;;
+- : string = "/features/0"
 ```
 
-With nested arrays:
+### Pointer Navigation
 
-```sh
-$ jsonpp add '{"arr":[[1,2],[3,4]]}' '/arr/0/1' '99'
-{"arr":[[1,99,2],[3,4]]}
+You can build pointers incrementally using `append`:
+
+```ocaml
+# let db_ptr = of_string "/database";;
+val db_ptr : t = <abstr>
+# let creds_ptr = append db_ptr (`Mem "credentials");;
+val creds_ptr : t = <abstr>
+# let user_ptr = append creds_ptr (`Mem "username");;
+val user_ptr : t = <abstr>
+# to_string user_ptr;;
+- : string = "/database/credentials/username"
+```
+
+Or concatenate two pointers:
+
+```ocaml
+# let base = of_string "/api/v1";;
+val base : t = <abstr>
+# let endpoint = of_string "/users/0";;
+val endpoint : t = <abstr>
+# to_string (concat base endpoint);;
+- : string = "/api/v1/users/0"
 ```
 
 ## Jsont Integration
···
 because you can point to a location in a JSON document and decode it
 directly to an OCaml type.
 
-Let's set up our OCaml environment and explore these features:
-
-```ocaml
-# open Jsont_pointer;;
-# 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>
-```
-
-### Working with JSON Values
-
-Let's create a sample configuration document:
-
 ```ocaml
 # let config_json = parse_json {|{
     "database": {
···
     <abstr>)
 ```
 
-### Creating and Using Pointers
-
-Create a pointer and use it to extract values:
-
-```ocaml
-# let host_ptr = of_string "/database/host";;
-val host_ptr : t = <abstr>
-# let host_value = get host_ptr config_json;;
-val host_value : Jsont.json = Jsont.String ("localhost", <abstr>)
-# match host_value with
-  | Jsont.String (s, _) -> s
-  | _ -> failwith "expected string";;
-- : string = "localhost"
-```
-
-### Building Pointers Programmatically
-
-Instead of parsing strings, you can build pointers from indices:
-
-```ocaml
-# let port_ptr = make [Mem "database"; Mem "port"];;
-val port_ptr : t = <abstr>
-# to_string port_ptr;;
-- : string = "/database/port"
-# match get port_ptr config_json with
-  | Jsont.Number (n, _) -> int_of_float n
-  | _ -> failwith "expected number";;
-- : int = 5432
-```
-
-For array access, use `Nth`:
-
-```ocaml
-# let first_feature_ptr = make [Mem "features"; Nth 0];;
-val first_feature_ptr : t = <abstr>
-# match get first_feature_ptr config_json with
-  | Jsont.String (s, _) -> s
-  | _ -> failwith "expected string";;
-- : string = "auth"
-```
-
-### Pointer Navigation
-
-You can build pointers incrementally using `append`:
-
-```ocaml
-# let db_ptr = of_string "/database";;
-val db_ptr : t = <abstr>
-# let creds_ptr = append db_ptr (Mem "credentials");;
-val creds_ptr : t = <abstr>
-# let user_ptr = append creds_ptr (Mem "username");;
-val user_ptr : t = <abstr>
-# to_string user_ptr;;
-- : string = "/database/credentials/username"
-# match get user_ptr config_json with
-  | Jsont.String (s, _) -> s
-  | _ -> failwith "expected string";;
-- : string = "admin"
-```
-
-### Safe Access with `find`
-
-Use `find` when you're not sure if a path exists:
-
-```ocaml
-# find (of_string "/database/timeout") config_json;;
-- : Jsont.json option = None
-# find (of_string "/database/host") config_json |> Option.is_some;;
-- : bool = true
-```
-
 ### Typed Access with `path`
 
 The `path` combinator combines pointer navigation with typed decoding:
···
       config_json
     |> Result.get_ok;;
 val timeout : int = 30
-```
-
-### Mutation Operations
-
-The library provides mutation functions for modifying JSON:
-
-```ocaml
-# let sample = parse_json {|{"name": "Alice", "scores": [85, 92, 78]}|};;
-val sample : Jsont.json =
-  Jsont.Object
-   ([(("name", <abstr>), Jsont.String ("Alice", <abstr>));
-     (("scores", <abstr>),
-      Jsont.Array
-       ([Jsont.Number (85., <abstr>); Jsont.Number (92., <abstr>);
-         Jsont.Number (78., <abstr>)],
-        <abstr>))],
-    <abstr>)
-```
-
-**Add** a new field:
-
-```ocaml
-# let with_email = add (of_string "/email") sample
-    ~value:(Jsont.Json.string "[e-mail]");;
-val with_email : Jsont.json =
-  Jsont.Object
-   ([(("name", <abstr>), Jsont.String ("Alice", <abstr>));
-     (("scores", <abstr>),
-      Jsont.Array
-       ([Jsont.Number (85., <abstr>); Jsont.Number (92., <abstr>);
-         Jsont.Number (78., <abstr>)],
-        <abstr>));
-     (("email", <abstr>), Jsont.String ("[e-mail]", <abstr>))],
-    <abstr>)
-# json_to_string with_email;;
-- : string =
-"{\"name\":\"Alice\",\"scores\":[85,92,78],\"email\":\"[e-mail]\"}"
-```
-
-**Add** to an array using `-` (append):
-
-```ocaml
-# let with_new_score = add (of_string "/scores/-") sample
-    ~value:(Jsont.Json.number 95.);;
-val with_new_score : Jsont.json =
-  Jsont.Object
-   ([(("name", <abstr>), Jsont.String ("Alice", <abstr>));
-     (("scores", <abstr>),
-      Jsont.Array
-       ([Jsont.Number (85., <abstr>); Jsont.Number (92., <abstr>);
-         Jsont.Number (78., <abstr>); Jsont.Number (95., <abstr>)],
-        <abstr>))],
-    <abstr>)
-# json_to_string with_new_score;;
-- : string = "{\"name\":\"Alice\",\"scores\":[85,92,78,95]}"
-```
-
-**Replace** an existing value:
-
-```ocaml
-# let renamed = replace (of_string "/name") sample
-    ~value:(Jsont.Json.string "Bob");;
-val renamed : Jsont.json =
-  Jsont.Object
-   ([(("name", <abstr>), Jsont.String ("Bob", <abstr>));
-     (("scores", <abstr>),
-      Jsont.Array
-       ([Jsont.Number (85., <abstr>); Jsont.Number (92., <abstr>);
-         Jsont.Number (78., <abstr>)],
-        <abstr>))],
-    <abstr>)
-# json_to_string renamed;;
-- : string = "{\"name\":\"Bob\",\"scores\":[85,92,78]}"
-```
-
-**Remove** a value:
-
-```ocaml
-# let without_first = remove (of_string "/scores/0") sample;;
-val without_first : Jsont.json =
-  Jsont.Object
-   ([(("name", <abstr>), Jsont.String ("Alice", <abstr>));
-     (("scores", <abstr>),
-      Jsont.Array
-       ([Jsont.Number (92., <abstr>); Jsont.Number (78., <abstr>)], <abstr>))],
-    <abstr>)
-# json_to_string without_first;;
-- : string = "{\"name\":\"Alice\",\"scores\":[92,78]}"
 ```
 
 ### Nested Path Extraction

src/jsont_pointer.ml

···
 
 (* Index type - represents how a token is interpreted in context *)
 module Index = struct
-  type t =
-    | Mem of string
-    | Nth of int
-    | End
+  type t = [ `Mem of string | `Nth of int | `End ]
 
   let pp ppf = function
-    | Mem s -> Format.fprintf ppf "/%s" (Token.escape s)
-    | Nth n -> Format.fprintf ppf "/%d" n
-    | End -> Format.fprintf ppf "/-"
+    | `Mem s -> Format.fprintf ppf "/%s" (Token.escape s)
+    | `Nth n -> Format.fprintf ppf "/%d" n
+    | `End -> Format.fprintf ppf "/-"
 
   let equal i1 i2 = match i1, i2 with
-    | Mem s1, Mem s2 -> String.equal s1 s2
-    | Nth n1, Nth n2 -> Int.equal n1 n2
-    | End, End -> true
+    | `Mem s1, `Mem s2 -> String.equal s1 s2
+    | `Nth n1, `Nth n2 -> Int.equal n1 n2
+    | `End, `End -> true
     | _ -> false
 
   let compare i1 i2 = match i1, i2 with
-    | Mem s1, Mem s2 -> String.compare s1 s2
-    | Mem _, _ -> -1
-    | _, Mem _ -> 1
-    | Nth n1, Nth n2 -> Int.compare n1 n2
-    | Nth _, End -> -1
-    | End, Nth _ -> 1
-    | End, End -> 0
+    | `Mem s1, `Mem s2 -> String.compare s1 s2
+    | `Mem _, _ -> -1
+    | _, `Mem _ -> 1
+    | `Nth n1, `Nth n2 -> Int.compare n1 n2
+    | `Nth _, `End -> -1
+    | `End, `Nth _ -> 1
+    | `End, `End -> 0
 
   let of_path_index (idx : Jsont.Path.index) : t =
     match idx with
-    | Jsont.Path.Mem (s, _meta) -> Mem s
-    | Jsont.Path.Nth (n, _meta) -> Nth n
+    | Jsont.Path.Mem (s, _meta) -> `Mem s
+    | Jsont.Path.Nth (n, _meta) -> `Nth n
 
   let to_path_index (idx : t) : Jsont.Path.index option =
     match idx with
-    | Mem s -> Some (Jsont.Path.Mem (s, Jsont.Meta.none))
-    | Nth n -> Some (Jsont.Path.Nth (n, Jsont.Meta.none))
-    | End -> None
+    | `Mem s -> Some (Jsont.Path.Mem (s, Jsont.Meta.none))
+    | `Nth n -> Some (Jsont.Path.Nth (n, Jsont.Meta.none))
+    | `End -> None
 end
 
 (* Internal representation: raw unescaped tokens.
···
   (* Convert to Index for a given JSON value type *)
   let to_index seg ~for_array =
     match seg with
-    | End -> Index.End
+    | End -> `End
     | Token s ->
       if for_array then
         match Token.is_valid_array_index s with
-        | Some n -> Index.Nth n
-        | None -> Index.Mem s  (* Invalid index becomes member for error msg *)
+        | Some n -> `Nth n
+        | None -> `Mem s  (* Invalid index becomes member for error msg *)
       else
-        Index.Mem s
+        `Mem s
 
   (* Convert from Index *)
   let of_index = function
-    | Index.End -> End
-    | Index.Mem s -> Token s
-    | Index.Nth n -> Token (string_of_int n)
+    | `End -> End
+    | `Mem s -> Token s
+    | `Nth n -> Token (string_of_int n)
 end
 
 (* Pointer type - list of segments *)

src/jsont_pointer.mli

···
     a numeric index or the special end-of-array marker [-]. *)
 module Index : sig
 
-  type t =
-    | Mem of string
-    (** [Mem name] indexes into an object member with the given [name].
+  type t = [
+    | `Mem of string
+    (** [`Mem name] indexes into an object member with the given [name].
         The name is unescaped (i.e., [/] and [~] appear literally). *)
-    | Nth of int
-    (** [Nth n] indexes into an array at position [n] (zero-based).
+    | `Nth of int
+    (** [`Nth n] indexes into an array at position [n] (zero-based).
         Must be non-negative and without leading zeros in string form
         (except for [0] itself). *)
-    | End
-    (** [End] represents the [-] token, indicating the position after
+    | `End
+    (** [`End] represents the [-] token, indicating the position after
         the last element of an array. This is used for append operations
         in {!Jsont_pointer.add} and similar mutation functions.
-        Evaluating a pointer containing [End] with {!Jsont_pointer.get}
+        Evaluating a pointer containing [`End] with {!Jsont_pointer.get}
         will raise an error since it refers to a nonexistent element. *)
+  ]
 
   val pp : Format.formatter -> t -> unit
   (** [pp] formats an index in JSON Pointer string notation. *)
···
 
   val to_path_index : t -> Jsont.Path.index option
   (** [to_path_index idx] converts to a {!Jsont.Path.index}.
-      Returns [None] for {!End} since it has no equivalent in
+      Returns [None] for [`End] since it has no equivalent in
       {!Jsont.Path}. *)
 end
 
···
     The string must be either empty (representing the root) or start
     with [/]. Each segment between [/] characters is unescaped as a
     reference token. Segments that are valid non-negative integers
-    without leading zeros become {!Index.Nth} indices; the string [-]
-    becomes {!Index.End}; all others become {!Index.Mem}.
+    without leading zeros become [`Nth] indices; the string [-]
+    becomes [`End]; all others become [`Mem].
 
     @raise Jsont.Error if [s] has invalid syntax:
     - Non-empty string not starting with [/]
···
 
 val to_path : t -> Jsont.Path.t option
 (** [to_path p] converts to a {!Jsont.Path.t}.
-    Returns [None] if [p] contains an {!Index.End} index. *)
+    Returns [None] if [p] contains an [`End] index. *)
 
 val to_path_exn : t -> Jsont.Path.t
 (** [to_path_exn p] is like {!to_path} but raises {!Jsont.Error}
···
     @raise Jsont.Error if:
     - The pointer references a nonexistent object member
     - The pointer references an out-of-bounds array index
-    - The pointer contains {!Index.End} (since [-] always refers
+    - The pointer contains [`End] (since [-] always refers
       to a nonexistent element)
-    - An index type doesn't match the JSON value (e.g., {!Index.Nth}
+    - An index type doesn't match the JSON value (e.g., [`Nth]
       on an object) *)
 
 val get_result : t -> Jsont.json -> (Jsont.json, Jsont.Error.t) result
···
 val set : t -> Jsont.json -> value:Jsont.json -> Jsont.json
 (** [set p json ~value] replaces the value at pointer [p] with [value].
 
-    For {!Index.End} on arrays, appends [value] to the end of the array.
+    For [`End] on arrays, appends [value] to the end of the array.
 
     @raise Jsont.Error if the pointer doesn't resolve to an existing
-    location (except for {!Index.End} on arrays). *)
+    location (except for [`End] on arrays). *)
 
 val add : t -> Jsont.json -> value:Jsont.json -> Jsont.json
 (** [add p json ~value] adds [value] at the location specified by [p].
···
     {ul
     {- For objects: If the member exists, it is replaced. If it doesn't
        exist, a new member is added.}
-    {- For arrays with {!Index.Nth}: Inserts [value] {e before} the
+    {- For arrays with [`Nth]: Inserts [value] {e before} the
        specified index, shifting subsequent elements. The index must be
        valid (0 to length inclusive).}
-    {- For arrays with {!Index.End}: Appends [value] to the array.}}
+    {- For arrays with [`End]: Appends [value] to the array.}}
 
     @raise Jsont.Error if:
     - The parent of the target location doesn't exist
-    - An array index is out of bounds (except for {!Index.End})
+    - An array index is out of bounds (except for [`End])
     - The parent is not an object or array *)
 
 val remove : t -> Jsont.json -> Jsont.json
···
     @raise Jsont.Error if:
     - [p] is the root (cannot remove the root)
     - The pointer doesn't resolve to an existing value
-    - The pointer contains {!Index.End} *)
+    - The pointer contains [`End] *)
 
 val replace : t -> Jsont.json -> value:Jsont.json -> Jsont.json
 (** [replace p json ~value] replaces the value at pointer [p] with [value].
···
 
     @raise Jsont.Error if:
     - The pointer doesn't resolve to an existing value
-    - The pointer contains {!Index.End} *)
+    - The pointer contains [`End] *)
 
 val move : from:t -> path:t -> Jsont.json -> Jsont.json
 (** [move ~from ~path json] moves the value from [from] to [path].
···
     @raise Jsont.Error if:
     - [from] doesn't resolve to a value
     - [path] is a proper prefix of [from] (would create a cycle)
-    - Either pointer contains {!Index.End} *)
+    - Either pointer contains [`End] *)
 
 val copy : from:t -> path:t -> Jsont.json -> Jsont.json
 (** [copy ~from ~path json] copies the value from [from] to [path].
···
 
     @raise Jsont.Error if:
     - [from] doesn't resolve to a value
-    - Either pointer contains {!Index.End} *)
+    - Either pointer contains [`End] *)
 
 val test : t -> Jsont.json -> expected:Jsont.json -> bool
 (** [test p json ~expected] tests if the value at [p] equals [expected].

test/test_pointer.ml

···
     let indices = Jsont_pointer.indices p in
     let index_strs = List.map (fun idx ->
       match idx with
-      | Jsont_pointer.Index.Mem s -> Printf.sprintf "Mem:%s" s
-      | Jsont_pointer.Index.Nth n -> Printf.sprintf "Nth:%d" n
-      | Jsont_pointer.Index.End -> "End"
+      | `Mem s -> Printf.sprintf "Mem:%s" s
+      | `Nth n -> Printf.sprintf "Nth:%d" n
+      | `End -> "End"
     ) indices in
     Printf.printf "OK: [%s]\n" (String.concat ", " index_strs)
   with Jsont.Error e ->