refactor

bin/jsonpp.ml

···
   | Ok s -> s
   | Error e -> failwith e
 
-(* Helper to get indices from either nav or append pointer *)
-let indices_of_result (result : [ `Nav of Jsont_pointer.nav Jsont_pointer.t
-                                | `Append of Jsont_pointer.append Jsont_pointer.t ]) =
-  match result with
-  | `Nav p -> Jsont_pointer.indices p
-  | `Append p -> Jsont_pointer.indices p
+(* Helper to get indices from any pointer *)
+let indices_of_any (Jsont_pointer.Any p) = Jsont_pointer.indices p
 
-(* Helper to convert to string from either nav or append pointer *)
-let to_string_of_result (result : [ `Nav of Jsont_pointer.nav Jsont_pointer.t
-                                  | `Append of Jsont_pointer.append Jsont_pointer.t ]) =
-  match result with
-  | `Nav p -> Jsont_pointer.to_string p
-  | `Append p -> Jsont_pointer.to_string p
+(* Helper to convert to string from any pointer *)
+let to_string_of_any (Jsont_pointer.Any p) = Jsont_pointer.to_string p
+
+(* Helper to check if pointer is append *)
+let is_append_any (Jsont_pointer.Any p : Jsont_pointer.any) =
+  not (Jsont_pointer.is_nav (Jsont_pointer.Any p))
 
 (* Test: parse pointer and print indices *)
 let test_parse pointer_str =
   try
     let result = Jsont_pointer.of_string pointer_str in
-    let indices = indices_of_result result in
+    let indices = indices_of_any result in
     let index_strs = List.map (fun idx ->
       match idx with
       | Jsont.Path.Mem (s, _) -> Printf.sprintf "Mem:%s" s
       | Jsont.Path.Nth (n, _) -> Printf.sprintf "Nth:%d" n
     ) indices in
-    let suffix = match result with `Nav _ -> "" | `Append _ -> ", /-" in
+    let suffix = if is_append_any result then ", /-" else "" in
     Printf.printf "OK: [%s%s]\n" (String.concat ", " index_strs) suffix
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
 let test_roundtrip pointer_str =
   try
     let result = Jsont_pointer.of_string pointer_str in
-    let s = to_string_of_result result in
+    let s = to_string_of_any result in
     if s = pointer_str then
       Printf.printf "OK: %s\n" s
     else
···
 let test_uri_fragment pointer_str =
   try
     let result = Jsont_pointer.of_string pointer_str in
-    let frag = match result with
-      | `Nav p -> Jsont_pointer.to_uri_fragment p
-      | `Append p -> Jsont_pointer.to_uri_fragment p
-    in
+    let (Jsont_pointer.Any p) = result in
+    let frag = Jsont_pointer.to_uri_fragment p in
     let result2 = Jsont_pointer.of_uri_fragment frag in
-    let s2 = to_string_of_result result2 in
+    let s2 = to_string_of_any result2 in
     if s2 = pointer_str then
       Printf.printf "OK: %s -> %s\n" pointer_str frag
     else
···
   try
     let json = parse_json json_str in
     let value = parse_json value_str in
-    let result = match Jsont_pointer.of_string pointer_str with
-      | `Nav p -> Jsont_pointer.add p json ~value
-      | `Append p -> Jsont_pointer.add p json ~value
-    in
+    let p = Jsont_pointer.of_string pointer_str in
+    let result = Jsont_pointer.add p json ~value in
     Printf.printf "%s\n" (json_to_string result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
   try
     let json = parse_json json_str in
     let from = Jsont_pointer.of_string_nav from_str in
-    let result = match Jsont_pointer.of_string path_str with
-      | `Nav path -> Jsont_pointer.move ~from ~path json
-      | `Append path -> Jsont_pointer.move ~from ~path json
-    in
+    let path = Jsont_pointer.of_string path_str in
+    let result = Jsont_pointer.move ~from ~path json in
     Printf.printf "%s\n" (json_to_string result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
   try
     let json = parse_json json_str in
     let from = Jsont_pointer.of_string_nav from_str in
-    let result = match Jsont_pointer.of_string path_str with
-      | `Nav path -> Jsont_pointer.copy ~from ~path json
-      | `Append path -> Jsont_pointer.copy ~from ~path json
-    in
+    let path = Jsont_pointer.of_string path_str in
+    let result = Jsont_pointer.copy ~from ~path json in
     Printf.printf "%s\n" (json_to_string result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

doc/tutorial.mld

···
 For example, given this JSON document:
 
 {x@ocaml[
-# let users_json =
-    parse_json "{\"users\":[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":25}]}";;
+# let users_json = parse_json {|{
+    "users": [
+      {"name": "Alice", "age": 30},
+      {"name": "Bob", "age": 25}
+    ]
+  }|};;
 val users_json : Jsont.json =
   {"users":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}
 ]x}
···
 
 Each reference token is represented using {!Jsont.Path.index}:
 
-{[
+{v
 type index = Jsont.Path.index
 (* = Jsont.Path.Mem of string * Jsont.Meta.t
    | Jsont.Path.Nth of int * Jsont.Meta.t *)
-]}
+v}
 
 The [Mem] constructor is for object member access, and [Nth] is for array
 index access. The member name is {b unescaped} - you work with the actual
···
 
 {@ocaml[
 # of_string_result "foo";;
-- : ([ `Append of append t | `Nav of nav t ], string) result =
+- : (any, string) result =
 Error "Invalid JSON Pointer: must be empty or start with '/': foo"
 # of_string_result "/valid";;
-- : ([ `Append of append t | `Nav of nav t ], string) result =
-Ok (`Nav [Mem "valid"])
+- : (any, string) result = Ok (Any <abstr>)
 ]}
 
 {1 Evaluation: Navigating JSON}
···
 
 Let's use the example JSON document from RFC 6901, Section 5:
 
-{@ocaml[
-# 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}";;
+{x@ocaml[
+# 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 =
   {"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}
-]}
+]x}
 
 This document is carefully constructed to exercise various edge cases!
 
···
 
 The library provides both exception-raising and result-returning variants:
 
-[
+{v
 val get : nav t -> Jsont.json -> Jsont.json
 val get_result : nav t -> Jsont.json -> (Jsont.json, Jsont.Error.t) result
 val find : nav t -> Jsont.json -> Jsont.json option
-]
+v}
 
 {2 Array Index Rules}
 
···
 between pointers that can be used for navigation and pointers that target
 the "append position":
 
-{[
+{v
 type nav     (* A pointer to an existing element *)
 type append  (* A pointer ending with "-" (append position) *)
 type 'a t    (* Pointer with phantom type parameter *)
-]}
+type any     (* Existential: wraps either nav or append *)
+v}
 
-When you parse a pointer, you get either a [nav t] or an [append t]:
+When you parse a pointer with {!of_string}, you get an {!any} pointer
+that can be used directly with mutation operations:
 
 {@ocaml[
 # of_string "/foo/0";;
-- : [ `Append of Jsont_pointer.append Jsont_pointer.t
-    | `Nav of Jsont_pointer.nav Jsont_pointer.t ]
-= `Nav [Mem "foo"; Nth 0]
+- : any = Any <abstr>
 # of_string "/foo/-";;
-- : [ `Append of Jsont_pointer.append Jsont_pointer.t
-    | `Nav of Jsont_pointer.nav Jsont_pointer.t ]
-= `Append [Mem "foo"] /-
+- : any = Any <abstr>
 ]}
 
-The [-] creates an [append] pointer. Note that in the internal
-representation, the append position is tracked separately (shown as [/-]).
+The [-] creates an append pointer. The {!any} type wraps either kind,
+making it ergonomic to use with operations like {!set} and {!add}.
 
-{2 Why Phantom Types?}
+{2 Why Two Pointer Types?}
 
 The RFC explains that [-] refers to a {e nonexistent} position:
 
···
 
 So you {b cannot use [get] or [find]} with an append pointer - it makes
 no sense to retrieve a value from a position that doesn't exist! The
-library enforces this at compile time.
+library enforces this:
+- Use {!of_string_nav} when you need to call {!get} or {!find}
+- Use {!of_string} (returns {!any}) for mutation operations
 
-However, append pointers {b are} valid for mutation operations like {!add}:
+Mutation operations like {!add} accept {!any} directly:
 
 {x@ocaml[
-# let arr_obj = parse_json "{\"foo\":[\"a\",\"b\"]}";;
+# let arr_obj = parse_json {|{"foo":["a","b"]}|};;
 val arr_obj : Jsont.json = {"foo":["a","b"]}
-# (match of_string "/foo/-" with `Append p -> add p arr_obj ~value:(Jsont.Json.string "c") | `Nav _ -> assert false);;
+# add (of_string "/foo/-") arr_obj ~value:(Jsont.Json.string "c");;
 - : Jsont.json = {"foo":["a","b","c"]}
 ]x}
 
-For convenience, use {!of_string_nav} when you know a pointer shouldn't
-contain [-]:
+For retrieval operations, use {!of_string_nav} which ensures the pointer
+doesn't contain [-]:
 
 {@ocaml[
 # of_string_nav "/foo/0";;
-- : Jsont_pointer.nav Jsont_pointer.t = [Mem "foo"; Nth 0]
+- : nav t = [Mem "foo"; Nth 0]
 # of_string_nav "/foo/-";;
 Exception:
 Jsont.Error Invalid JSON Pointer: '-' not allowed in navigation pointer.
···
 
 {@ocaml[
 # let nav_ptr = of_string_nav "/foo";;
-val nav_ptr : Jsont_pointer.nav Jsont_pointer.t = [Mem "foo"]
+val nav_ptr : nav t = [Mem "foo"]
 # let app_ptr = at_end nav_ptr;;
-val app_ptr : Jsont_pointer.append Jsont_pointer.t = [Mem "foo"] /-
+val app_ptr : append t = [Mem "foo"] /-
 # to_string app_ptr;;
 - : string = "/foo/-"
 ]}
···
 (JSON Patch) uses JSON Pointer for modifications. The [jsont-pointer]
 library provides these operations.
 
-{2 Which Pointer Type for Which Operation?}
-
-The phantom type system enforces correct usage:
-
-{ul
-{- {!get}, {!find} - [nav t] only - Can't retrieve from non-existent position}
-{- {!remove} - [nav t] only - Can't remove what doesn't exist}
-{- {!replace} - [nav t] only - Can't replace what doesn't exist}
-{- {!test} - [nav t] only - Can't test non-existent position}
-{- {!add} - [_ t] (both) - Can add at existing position OR append}
-{- {!set} - [_ t] (both) - Can set existing position OR append}
-{- {!move}, {!copy} - [from:nav t], [path:_ t] - Source must exist, dest can be append}
-}
-
 {2 Add}
 
-The {!add} operation inserts a value at a location:
+The {!add} operation inserts a value at a location. It accepts {!any}
+pointers, so you can use {!of_string} directly:
 
-{@ocaml[
-# let obj = parse_json "{\"foo\":\"bar\"}";;
+{x@ocaml[
+# let obj = parse_json {|{"foo":"bar"}|};;
 val obj : Jsont.json = {"foo":"bar"}
-# add (of_string_nav "/baz") obj ~value:(Jsont.Json.string "qux")
-  ;;
+# add (of_string "/baz") obj ~value:(Jsont.Json.string "qux");;
 - : Jsont.json = {"foo":"bar","baz":"qux"}
-]}
+]x}
 
 For arrays, {!add} inserts BEFORE the specified index:
 
 {x@ocaml[
-# let arr_obj = parse_json "{\"foo\":[\"a\",\"b\"]}";;
+# let arr_obj = parse_json {|{"foo":["a","b"]}|};;
 val arr_obj : Jsont.json = {"foo":["a","b"]}
-# add (of_string_nav "/foo/1") arr_obj ~value:(Jsont.Json.string "X")
-  ;;
+# add (of_string "/foo/1") arr_obj ~value:(Jsont.Json.string "X");;
 - : Jsont.json = {"foo":["a","X","b"]}
 ]x}
 
-This is where the [-] marker and append pointers shine - they append to the end:
+This is where the [-] marker shines - it appends to the end:
 
 {x@ocaml[
-# (match of_string "/foo/-" with `Append p -> add p arr_obj ~value:(Jsont.Json.string "c") | `Nav _ -> assert false);;
+# add (of_string "/foo/-") arr_obj ~value:(Jsont.Json.string "c");;
 - : Jsont.json = {"foo":["a","b","c"]}
 ]x}
 
-Or more conveniently using {!at_end}:
+You can also use {!at_end} to create an append pointer programmatically:
 
 {x@ocaml[
-# add (at_end (of_string_nav "/foo")) arr_obj ~value:(Jsont.Json.string "c")
-  ;;
+# add (any (at_end (of_string_nav "/foo"))) arr_obj ~value:(Jsont.Json.string "c");;
 - : Jsont.json = {"foo":["a","b","c"]}
 ]x}
 
+{2 Ergonomic Mutation with [any]}
+
+Since {!add}, {!set}, {!move}, and {!copy} accept {!any} pointers, you can
+use {!of_string} directly without any pattern matching. This makes JSON
+Patch implementations straightforward:
+
+{x@ocaml[
+# let items = parse_json {|{"items":["x"]}|};;
+val items : Jsont.json = {"items":["x"]}
+# add (of_string "/items/0") items ~value:(Jsont.Json.string "y");;
+- : Jsont.json = {"items":["y","x"]}
+# add (of_string "/items/-") items ~value:(Jsont.Json.string "z");;
+- : Jsont.json = {"items":["x","z"]}
+]x}
+
+The same pointer works whether it targets an existing position or the
+append marker - no conditional logic needed.
+
 {2 Remove}
 
 The {!remove} operation deletes a value. It only accepts [nav t] because
 you can only remove something that exists:
 
-{@ocaml[
-# let two_fields = parse_json "{\"foo\":\"bar\",\"baz\":\"qux\"}";;
+{x@ocaml[
+# let two_fields = parse_json {|{"foo":"bar","baz":"qux"}|};;
 val two_fields : Jsont.json = {"foo":"bar","baz":"qux"}
 # remove (of_string_nav "/baz") two_fields ;;
 - : Jsont.json = {"foo":"bar"}
-]}
+]x}
 
 For arrays, it removes and shifts:
 
 {x@ocaml[
-# let three_elem = parse_json "{\"foo\":[\"a\",\"b\",\"c\"]}";;
+# let three_elem = parse_json {|{"foo":["a","b","c"]}|};;
 val three_elem : Jsont.json = {"foo":["a","b","c"]}
 # remove (of_string_nav "/foo/1") three_elem ;;
 - : Jsont.json = {"foo":["a","c"]}
···
 {2 Move}
 
 The {!move} operation relocates a value. The source ([from]) must be a [nav t]
-(you can only move something that exists), but the destination ([path]) can
-be either:
+(you can only move something that exists), but the destination ([path])
+accepts {!any}:
 
-{@ocaml[
-# let nested = parse_json "{\"foo\":{\"bar\":\"baz\"},\"qux\":{}}";;
+{x@ocaml[
+# let nested = parse_json {|{"foo":{"bar":"baz"},"qux":{}}|};;
 val nested : Jsont.json = {"foo":{"bar":"baz"},"qux":{}}
-# move ~from:(of_string_nav "/foo/bar") ~path:(of_string_nav "/qux/thud") nested
-  ;;
+# move ~from:(of_string_nav "/foo/bar") ~path:(of_string "/qux/thud") nested;;
 - : Jsont.json = {"foo":{},"qux":{"thud":"baz"}}
-]}
+]x}
 
 {2 Copy}
 
 The {!copy} operation duplicates a value (same typing as {!move}):
 
-{@ocaml[
-# let to_copy = parse_json "{\"foo\":{\"bar\":\"baz\"}}";;
+{x@ocaml[
+# let to_copy = parse_json {|{"foo":{"bar":"baz"}}|};;
 val to_copy : Jsont.json = {"foo":{"bar":"baz"}}
-# copy ~from:(of_string_nav "/foo/bar") ~path:(of_string_nav "/foo/qux") to_copy
-  ;;
+# copy ~from:(of_string_nav "/foo/bar") ~path:(of_string "/foo/qux") to_copy;;
 - : Jsont.json = {"foo":{"bar":"baz","qux":"baz"}}
-]}
+]x}
 
 {2 Test}
 
···
 
 {@ocaml[
 # let p = make [mem "a/b"];;
-val p : Jsont_pointer.nav Jsont_pointer.t = [Mem "a/b"]
+val p : nav t = [Mem "a/b"]
 # to_string p;;
 - : string = "/a~1b"
 # of_string_nav "/a~1b";;
-- : Jsont_pointer.nav Jsont_pointer.t = [Mem "a/b"]
+- : nav t = [Mem "a/b"]
 ]}
 
 {2 Escaping in Action}
···
 Here's the RFC example showing the URI fragment forms:
 
 {ul
-{- [""] → [#] → whole document}
-{- ["/foo"] → [#/foo] → [["bar", "baz"]]}
-{- ["/foo/0"] → [#/foo/0] → ["bar"]}
-{- ["/"] → [#/] → [0]}
-{- ["/a~1b"] → [#/a~1b] → [1]}
-{- ["/c%d"] → [#/c%25d] → [2]}
-{- ["/ "] → [#/%20] → [7]}
-{- ["/m~0n"] → [#/m~0n] → [8]}
+{- [""] -> [#] -> whole document}
+{- ["/foo"] -> [#/foo] -> [["bar", "baz"]]}
+{- ["/foo/0"] -> [#/foo/0] -> ["bar"]}
+{- ["/"] -> [#/] -> [0]}
+{- ["/a~1b"] -> [#/a~1b] -> [1]}
+{- ["/c%d"] -> [#/c%25d] -> [2]}
+{- ["/ "] -> [#/%20] -> [7]}
+{- ["/m~0n"] -> [#/m~0n] -> [8]}
 }
 
 {1 Building Pointers Programmatically}
···
 
 {@ocaml[
 # let port_ptr = make [mem "database"; mem "port"];;
-val port_ptr : Jsont_pointer.nav Jsont_pointer.t =
-  [Mem "database"; Mem "port"]
+val port_ptr : nav t = [Mem "database"; Mem "port"]
 # to_string port_ptr;;
 - : string = "/database/port"
 ]}
···
 
 {@ocaml[
 # let first_feature_ptr = make [mem "features"; nth 0];;
-val first_feature_ptr : Jsont_pointer.nav Jsont_pointer.t =
-  [Mem "features"; Nth 0]
+val first_feature_ptr : nav t = [Mem "features"; Nth 0]
 # to_string first_feature_ptr;;
 - : string = "/features/0"
 ]}
···
 
 {@ocaml[
 # let db_ptr = of_string_nav "/database";;
-val db_ptr : Jsont_pointer.nav Jsont_pointer.t = [Mem "database"]
+val db_ptr : nav t = [Mem "database"]
 # let creds_ptr = db_ptr / mem "credentials";;
-val creds_ptr : Jsont_pointer.nav Jsont_pointer.t =
-  [Mem "database"; Mem "credentials"]
+val creds_ptr : nav t = [Mem "database"; Mem "credentials"]
 # let user_ptr = creds_ptr / mem "username";;
-val user_ptr : Jsont_pointer.nav Jsont_pointer.t =
-  [Mem "database"; Mem "credentials"; Mem "username"]
+val user_ptr : nav t = [Mem "database"; Mem "credentials"; Mem "username"]
 # to_string user_ptr;;
 - : string = "/database/credentials/username"
 ]}
···
 
 {@ocaml[
 # let base = of_string_nav "/api/v1";;
-val base : Jsont_pointer.nav Jsont_pointer.t = [Mem "api"; Mem "v1"]
+val base : nav t = [Mem "api"; Mem "v1"]
 # let endpoint = of_string_nav "/users/0";;
-val endpoint : Jsont_pointer.nav Jsont_pointer.t = [Mem "users"; Nth 0]
+val endpoint : nav t = [Mem "users"; Nth 0]
 # to_string (concat base endpoint);;
 - : string = "/api/v1/users/0"
 ]}
···
 directly to an OCaml type.
 
 {x@ocaml[
-# let config_json = parse_json "{\"database\":{\"host\":\"localhost\",\"port\":5432,\"credentials\":{\"username\":\"admin\",\"password\":\"secret\"}},\"features\":[\"auth\",\"logging\",\"metrics\"]}";;
+# let config_json = parse_json {|{
+    "database": {
+      "host": "localhost",
+      "port": 5432,
+      "credentials": {"username": "admin", "password": "secret"}
+    },
+    "features": ["auth", "logging", "metrics"]
+  }|};;
 val config_json : Jsont.json =
   {"database":{"host":"localhost","port":5432,"credentials":{"username":"admin","password":"secret"}},"features":["auth","logging","metrics"]}
 ]x}
···
 The {!path} combinator combines pointer navigation with typed decoding:
 
 {@ocaml[
+# let nav = of_string_nav "/database/host";;
+val nav : nav t = [Mem "database"; Mem "host"]
 # let db_host =
     Jsont.Json.decode
-      (path (of_string_nav "/database/host") Jsont.string)
+      (path nav Jsont.string)
       config_json
     |> Result.get_ok;;
 val db_host : string = "localhost"
···
 You can extract values from deeply nested structures:
 
 {x@ocaml[
-# let org_json = parse_json "{\"organization\":{\"owner\":{\"name\":\"Alice\",\"email\":\"[e-mail]\",\"age\":35},\"members\":[{\"name\":\"Bob\",\"email\":\"[e-mail]\",\"age\":28}]}}";;
+# let org_json = parse_json {|{
+    "organization": {
+      "owner": {"name": "Alice", "email": "[e-mail]", "age": 35},
+      "members": [{"name": "Bob", "email": "[e-mail]", "age": 28}]
+    }
+  }|};;
 val org_json : Jsont.json =
   {"organization":{"owner":{"name":"Alice","email":"[e-mail]","age":35},"members":[{"name":"Bob","email":"[e-mail]","age":28}]}}
 # Jsont.Json.decode
···
 
 The typed approach catches mismatches at decode time with clear errors.
 
+{2 Updates with Polymorphic Pointers}
+
+The {!set} and {!add} functions accept {!any} pointers, which means you can
+use the result of {!of_string} directly without pattern matching:
+
+{x@ocaml[
+# let tasks = parse_json {|{"tasks":["buy milk"]}|};;
+val tasks : Jsont.json = {"tasks":["buy milk"]}
+# set (of_string "/tasks/0") tasks ~value:(Jsont.Json.string "buy eggs");;
+- : Jsont.json = {"tasks":["buy eggs"]}
+# set (of_string "/tasks/-") tasks ~value:(Jsont.Json.string "call mom");;
+- : Jsont.json = {"tasks":["buy milk","call mom"]}
+]x}
+
+This is useful for implementing JSON Patch ([RFC 6902]) where
+operations like ["add"] can target either existing positions or the
+append marker. If you need to distinguish between pointer types at runtime,
+use {!of_string_kind} which returns a polymorphic variant:
+
+{x@ocaml[
+# of_string_kind "/tasks/0";;
+- : [ `Append of append t | `Nav of nav t ] = `Nav [Mem "tasks"; Nth 0]
+# of_string_kind "/tasks/-";;
+- : [ `Append of append t | `Nav of nav t ] = `Append [Mem "tasks"] /-
+]x}
+
 {1 Summary}
 
 JSON Pointer (RFC 6901) provides a simple but powerful way to address
···
 {- {b Evaluation}: Tokens navigate through objects (by key) and arrays (by index)}
 {- {b URI Encoding}: Pointers can be percent-encoded for use in URIs}
 {- {b Mutations}: Combined with JSON Patch (RFC 6902), pointers enable structured updates}
-{- {b Type Safety}: Phantom types ([nav t] vs [append t]) prevent misuse of append pointers with retrieval operations}
+{- {b Type Safety}: Phantom types ([nav t] vs [append t]) prevent misuse of append pointers with retrieval operations, while the [any] existential type allows ergonomic use with mutation operations}
 }
 
 The [jsont-pointer] library implements all of this with type-safe OCaml

src/jsont_pointer.ml

···
   is_append : bool;  (* true if ends with "-" *)
 }
 
+(* Existential wrapper *)
+type any = Any : _ t -> any
+
 let root = { segments = []; is_append = false }
 
 let is_root p = p.segments = [] && not p.is_append
···
 
 let indices (type a) (p : a t) = List.map Segment.to_index p.segments
 
+(* Coercion and inspection *)
+
+let any (type a) (p : a t) : any = Any p
+
+let is_nav (Any p) = not p.is_append
+
+let to_nav (Any p) =
+  if p.is_append then None
+  else Some { segments = p.segments; is_append = false }
+
+let to_nav_exn (Any p) =
+  if p.is_append then
+    Jsont.Error.msgf Jsont.Meta.none
+      "JSON Pointer: cannot convert append pointer to nav pointer"
+  else
+    { segments = p.segments; is_append = false }
+
 (* Parsing *)
 
 let parse_segments s =
···
     let tokens = String.split_on_char '/' rest in
     List.map Segment.of_escaped_string tokens
 
-let of_string s : [ `Nav of nav t | `Append of append t ] =
+let of_string_kind s : [ `Nav of nav t | `Append of append t ] =
   let segments = parse_segments s in
   (* Check if ends with "-" *)
   match List.rev segments with
···
         "Invalid JSON Pointer: '-' can only appear at the end";
     `Nav { segments; is_append = false }
 
+let of_string s : any =
+  match of_string_kind s with
+  | `Nav p -> Any p
+  | `Append p -> Any p
+
 let of_string_nav s : nav t =
-  match of_string s with
+  match of_string_kind s with
   | `Nav p -> p
   | `Append _ ->
     Jsont.Error.msgf Jsont.Meta.none
···
   in
   loop 0
 
-let of_uri_fragment s = of_string (percent_decode s)
+let of_uri_fragment s : any = of_string (percent_decode s)
 
 let of_uri_fragment_nav s = of_string_nav (percent_decode s)
 
-let of_uri_fragment_result s =
+let of_uri_fragment_result s : (any, string) result =
   try Ok (of_uri_fragment s)
   with Jsont.Error e -> Error (Jsont.Error.to_string e)
 
···
         | None -> error_index_out_of_bounds json n)
       ~on_other:(fun () -> error_cannot_navigate json)
 
-let set (type a) (p : a t) json ~value =
+let set (Any p) json ~value =
   eval_set_segments p.segments p.is_append value json
 
 (* Mutation: add (RFC 6902 semantics) - works with any pointer type *)
···
         | None -> error_index_out_of_bounds json n)
       ~on_other:(fun () -> error_cannot_navigate json)
 
-let add (type a) (p : a t) json ~value =
+let add (Any p) json ~value =
   eval_add_segments p.segments p.is_append value json
 
 (* Mutation: remove - only for nav pointers *)
···
 
 (* Mutation: move *)
 
-let move ~(from : nav t) ~(path : _ t) json =
+let move ~(from : nav t) ~(path : any) json =
+  let (Any p) = path in
   (* Check for cycle: path cannot be a proper prefix of from *)
   let from_segs = from.segments in
-  let path_segs = path.segments in
+  let path_segs = p.segments in
   let rec is_prefix p1 p2 = match p1, p2 with
     | [], _ -> true
     | _, [] -> false
     | h1 :: t1, h2 :: t2 -> String.equal h1 h2 && is_prefix t1 t2
   in
   if is_prefix path_segs from_segs &&
-     not (List.equal String.equal path_segs from_segs && path.is_append = false) then
+     not (List.equal String.equal path_segs from_segs && p.is_append = false) then
     Jsont.Error.msgf Jsont.Meta.none
       "JSON Pointer: move would create cycle (path is prefix of from)";
   let value = get from json in
···
 
 (* Mutation: copy *)
 
-let copy ~(from : nav t) ~(path : _ t) json =
+let copy ~(from : nav t) ~(path : any) json =
   let value = get from json in
   add path json ~value
 
···
 
 (* Jsont codec *)
 
-let jsont : [ `Nav of nav t | `Append of append t ] Jsont.t =
+let jsont : any Jsont.t =
   let dec _meta s = of_string s in
+  let enc (Any p) = to_string p in
+  Jsont.Base.string (Jsont.Base.map
+    ~kind:"JSON Pointer"
+    ~doc:"RFC 6901 JSON Pointer"
+    ~dec ~enc ())
+
+let jsont_kind : [ `Nav of nav t | `Append of append t ] Jsont.t =
+  let dec _meta s = of_string_kind s in
   let enc = function
     | `Nav p -> to_string p
     | `Append p -> to_string p
   in
   Jsont.Base.string (Jsont.Base.map
-    ~kind:"JSON Pointer"
-    ~doc:"RFC 6901 JSON Pointer"
+    ~kind:"JSON Pointer (kind)"
+    ~doc:"RFC 6901 JSON Pointer with kind tag"
     ~dec ~enc ())
 
 let jsont_nav : nav t Jsont.t =
···
     ~doc:"RFC 6901 JSON Pointer (navigation only)"
     ~dec ~enc ())
 
-let jsont_uri_fragment : [ `Nav of nav t | `Append of append t ] Jsont.t =
+let jsont_uri_fragment : any Jsont.t =
   let dec _meta s = of_uri_fragment s in
-  let enc = function
-    | `Nav p -> to_uri_fragment p
-    | `Append p -> to_uri_fragment p
-  in
+  let enc (Any p) = to_uri_fragment p in
   Jsont.Base.string (Jsont.Base.map
     ~kind:"JSON Pointer (URI fragment)"
     ~doc:"RFC 6901 JSON Pointer in URI fragment encoding"
···
   Jsont.map Jsont.json ~dec ~enc:(fun _ ->
     Jsont.Error.msgf Jsont.Meta.none "path: encode not supported")
 
-let set_path (type a) ?(allow_absent = false) t (p : a t) v =
+let set_path ?(allow_absent = false) t (p : any) v =
   let encoded = match Jsont.Json.encode' t v with
     | Ok json -> json
     | Error e -> raise (Jsont.Error e)
···
       | Ok j -> j
       | Error e -> raise (Jsont.Error e)
     in
-    set p json ~value:re_encoded
+    set (Any p) json ~value:re_encoded
   in
   Jsont.map Jsont.json ~dec ~enc:(fun j -> j)
 

src/jsont_pointer.mli

···
 (** Phantom type for pointers ending with [-] (the "after last element"
     position). These can only be used with {!add} and {!set}. *)
 
+(** {2 Existential wrapper}
+
+    The {!any} type wraps a pointer of unknown phantom type, allowing
+    ergonomic use with mutation operations like {!set} and {!add} without
+    needing to pattern match on the pointer kind. *)
+
+type any = Any : _ t -> any
+(** Existential wrapper for pointers. Use this when you don't need to
+    distinguish between navigation and append pointers at the type level,
+    such as when using {!set} or {!add} which accept either kind. *)
+
 val root : nav t
 (** [root] is the empty pointer that references the whole document.
     In string form this is [""]. *)
···
     Note: for append pointers, this returns the indices of the path
     portion; the [-] (append position) is not represented as an index. *)
 
+(** {2:coercion Coercion and inspection} *)
+
+val any : _ t -> any
+(** [any p] wraps a typed pointer in the existential {!any} type.
+    Use this when you have a [nav t] or [append t] but need an {!any}
+    for use with functions like {!set} or {!add}. *)
+
+val is_nav : any -> bool
+(** [is_nav p] is [true] if [p] is a navigation pointer (not an append
+    pointer ending with [-]). *)
+
+val to_nav : any -> nav t option
+(** [to_nav p] returns [Some nav_p] if [p] is a navigation pointer,
+    or [None] if it's an append pointer. *)
+
+val to_nav_exn : any -> nav t
+(** [to_nav_exn p] returns the navigation pointer if [p] is one.
+    @raise Jsont.Error if [p] is an append pointer. *)
+
 (** {2:parsing Parsing} *)
 
-val of_string : string -> [ `Nav of nav t | `Append of append t ]
+val of_string : string -> any
 (** [of_string s] parses a JSON Pointer from its string representation.
 
-    Returns [`Nav p] for pointers without [-], or [`Append p] for
-    pointers ending with [-].
+    Returns an {!any} pointer that can be used directly with mutation
+    operations like {!set} and {!add}. For retrieval operations like
+    {!get}, use {!of_string_nav} instead.
 
     The string must be either empty (representing the root) or start
     with [/]. Each segment between [/] characters is unescaped as a
···
     - Invalid escape sequence ([~] not followed by [0] or [1])
     - [-] appears in non-final position *)
 
+val of_string_kind : string -> [ `Nav of nav t | `Append of append t ]
+(** [of_string_kind s] parses a JSON Pointer and returns a tagged variant
+    indicating whether it's a navigation or append pointer.
+
+    Use this when you need to handle navigation and append pointers
+    differently, or when you need a typed pointer for operations that
+    require a specific kind.
+
+    @raise Jsont.Error if [s] has invalid syntax. *)
+
 val of_string_nav : string -> nav t
 (** [of_string_nav s] parses a JSON Pointer that must not contain [-].
+
+    Use this when you need a {!nav} pointer for retrieval operations
+    like {!get} or {!find}.
 
     @raise Jsont.Error if [s] has invalid syntax or contains [-]. *)
 
-val of_string_result : string -> ([ `Nav of nav t | `Append of append t ], string) result
+val of_string_result : string -> (any, string) result
 (** [of_string_result s] is like {!of_string} but returns a result
     instead of raising. *)
 
-val of_uri_fragment : string -> [ `Nav of nav t | `Append of append t ]
+val of_uri_fragment : string -> any
 (** [of_uri_fragment s] parses a JSON Pointer from URI fragment form.
 
     This is like {!of_string} but first percent-decodes the string
···
 
     @raise Jsont.Error if invalid or contains [-]. *)
 
-val of_uri_fragment_result : string -> ([ `Nav of nav t | `Append of append t ], string) result
+val of_uri_fragment_result : string -> (any, string) result
 (** [of_uri_fragment_result s] is like {!of_uri_fragment} but returns
     a result instead of raising. *)
 
···
     All mutation functions return a new JSON value with the modification
     applied; they do not mutate the input.
 
-    Functions that support the [-] token ({!add}, {!set}) accept any
-    pointer type ([_ t]). Functions that require an existing element
-    ({!remove}, {!replace}) only accept {!nav} pointers. *)
+    Functions that support the [-] token ({!set}, {!add}, {!move}, {!copy})
+    accept {!any} pointers, making them easy to use with {!of_string}.
+    Functions that require an existing element ({!remove}, {!replace})
+    only accept {!nav} pointers. *)
 
-val set : _ t -> Jsont.json -> value:Jsont.json -> Jsont.json
+val set : any -> Jsont.json -> value:Jsont.json -> Jsont.json
 (** [set p json ~value] replaces the value at pointer [p] with [value].
 
     For {!append} pointers, appends [value] to the end of the array.
 
+    This accepts {!any} pointers directly from {!of_string}:
+    {[set (of_string "/tasks/-") json ~value:(Jsont.Json.string "new task")]}
+
     @raise Jsont.Error if the pointer doesn't resolve to an existing
     location (except for {!append} pointers on arrays). *)
 
-val add : _ t -> Jsont.json -> value:Jsont.json -> Jsont.json
+val add : any -> Jsont.json -> value:Jsont.json -> Jsont.json
 (** [add p json ~value] adds [value] at the location specified by [p].
 
     The behavior depends on the target:
···
 
     @raise Jsont.Error if the pointer doesn't resolve to an existing value. *)
 
-val move : from:nav t -> path:_ t -> Jsont.json -> Jsont.json
+val move : from:nav t -> path:any -> Jsont.json -> Jsont.json
 (** [move ~from ~path json] moves the value from [from] to [path].
 
     This is equivalent to {!remove} at [from] followed by {!add}
···
     - [from] doesn't resolve to a value
     - [path] is a proper prefix of [from] (would create a cycle) *)
 
-val copy : from:nav t -> path:_ t -> Jsont.json -> Jsont.json
+val copy : from:nav t -> path:any -> Jsont.json -> Jsont.json
 (** [copy ~from ~path json] copies the value from [from] to [path].
 
     This is equivalent to {!get} at [from] followed by {!add}
···
     These types and functions integrate JSON Pointers with the {!Jsont}
     codec system. *)
 
-val jsont : [ `Nav of nav t | `Append of append t ] Jsont.t
+val jsont : any Jsont.t
 (** [jsont] is a {!Jsont.t} codec for JSON Pointers.
 
     On decode, parses a JSON string as a JSON Pointer using {!of_string}.
     On encode, serializes a pointer to a JSON string using {!to_string}. *)
 
+val jsont_kind : [ `Nav of nav t | `Append of append t ] Jsont.t
+(** [jsont_kind] is a {!Jsont.t} codec for JSON Pointers that preserves
+    the pointer kind in the type.
+
+    On decode, parses using {!of_string_kind}.
+    On encode, serializes using {!to_string}. *)
+
 val jsont_nav : nav t Jsont.t
 (** [jsont_nav] is a {!Jsont.t} codec for navigation JSON Pointers.
 
     On decode, parses using {!of_string_nav} (fails on [-]).
     On encode, serializes using {!to_string}. *)
 
-val jsont_uri_fragment : [ `Nav of nav t | `Append of append t ] Jsont.t
+val jsont_uri_fragment : any Jsont.t
 (** [jsont_uri_fragment] is like {!jsont} but uses URI fragment encoding.
 
     On decode, parses using {!of_uri_fragment}.
···
 
     This is similar to {!Jsont.path} but uses JSON Pointer syntax. *)
 
-val set_path : ?allow_absent:bool -> 'a Jsont.t -> _ t -> 'a -> Jsont.json Jsont.t
+val set_path : ?allow_absent:bool -> 'a Jsont.t -> any -> 'a -> Jsont.json Jsont.t
 (** [set_path t p v] sets the value at pointer [p] to [v] encoded with [t].
 
     If [allow_absent] is [true] (default [false]), creates missing

test/api.t

···
+JSON Pointer API Test Suite
+
+This tests all functions exposed in jsont_pointer.mli.
+
+================================================================================
+Index Functions (mem, nth, pp_index, equal_index, compare_index)
+================================================================================
+
+Creating indices with mem:
+  $ ./test_pointer.exe mem "foo"
+  mem(foo) = /foo
+  $ ./test_pointer.exe mem ""
+  mem() = /
+  $ ./test_pointer.exe mem "a/b"
+  mem(a/b) = /a~1b
+  $ ./test_pointer.exe mem "m~n"
+  mem(m~n) = /m~0n
+
+Creating indices with nth:
+  $ ./test_pointer.exe nth 0
+  nth(0) = /0
+  $ ./test_pointer.exe nth 5
+  nth(5) = /5
+  $ ./test_pointer.exe nth 123
+  nth(123) = /123
+
+Testing index equality:
+  $ ./test_pointer.exe equal-index "foo" "foo"
+  true
+  $ ./test_pointer.exe equal-index "foo" "bar"
+  false
+  $ ./test_pointer.exe equal-index "0" "0"
+  true
+  $ ./test_pointer.exe equal-index "0" "1"
+  false
+  $ ./test_pointer.exe equal-index "foo" "0"
+  false
+
+Testing index comparison:
+  $ ./test_pointer.exe compare-index "foo" "foo"
+  EQ
+  $ ./test_pointer.exe compare-index "aaa" "bbb"
+  LT
+  $ ./test_pointer.exe compare-index "bbb" "aaa"
+  GT
+  $ ./test_pointer.exe compare-index "0" "0"
+  EQ
+  $ ./test_pointer.exe compare-index "0" "5"
+  LT
+  $ ./test_pointer.exe compare-index "5" "0"
+  GT
+  $ ./test_pointer.exe compare-index "foo" "0"
+  LT
+  $ ./test_pointer.exe compare-index "0" "foo"
+  GT
+
+================================================================================
+Pointer Constructors (root, is_root, make, /, append_index, at_end, concat, parent, last)
+================================================================================
+
+Root pointer:
+  $ ./test_pointer.exe root
+  root = 
+  is_root(root) = true
+
+Testing is_root:
+  $ ./test_pointer.exe is-root ""
+  true
+  $ ./test_pointer.exe is-root "/foo"
+  false
+  $ ./test_pointer.exe is-root "/foo/bar"
+  false
+
+Making pointers from indices:
+  $ ./test_pointer.exe make "foo"
+  /foo
+  $ ./test_pointer.exe make "foo,bar"
+  /foo/bar
+  $ ./test_pointer.exe make "foo,0,bar"
+  /foo/0/bar
+  $ ./test_pointer.exe make "0,1,2"
+  /0/1/2
+
+Appending index to pointer:
+  $ ./test_pointer.exe append-index "" "foo"
+  /foo
+  $ ./test_pointer.exe append-index "/foo" "bar"
+  /foo/bar
+  $ ./test_pointer.exe append-index "/foo" "0"
+  /foo/0
+  $ ./test_pointer.exe append-index "/foo/bar" "baz"
+  /foo/bar/baz
+
+Creating append pointers with at_end:
+  $ ./test_pointer.exe at-end ""
+  /-
+  $ ./test_pointer.exe at-end "/foo"
+  /foo/-
+  $ ./test_pointer.exe at-end "/foo/bar"
+  /foo/bar/-
+
+Concatenating pointers:
+  $ ./test_pointer.exe concat "" ""
+  
+
+  $ ./test_pointer.exe concat "/foo" ""
+  /foo
+  $ ./test_pointer.exe concat "" "/bar"
+  /bar
+  $ ./test_pointer.exe concat "/foo" "/bar"
+  /foo/bar
+  $ ./test_pointer.exe concat "/a/b" "/c/d"
+  /a/b/c/d
+
+Getting parent pointer:
+  $ ./test_pointer.exe parent ""
+  None
+  $ ./test_pointer.exe parent "/foo"
+  Some()
+  $ ./test_pointer.exe parent "/foo/bar"
+  Some(/foo)
+  $ ./test_pointer.exe parent "/a/b/c"
+  Some(/a/b)
+
+Getting last index:
+  $ ./test_pointer.exe last ""
+  None
+  $ ./test_pointer.exe last "/foo"
+  Some(/foo)
+  $ ./test_pointer.exe last "/foo/bar"
+  Some(/bar)
+  $ ./test_pointer.exe last "/foo/0"
+  Some(/0)
+
+Getting all indices:
+  $ ./test_pointer.exe indices ""
+  []
+  $ ./test_pointer.exe indices "/foo"
+  [Mem:foo]
+  $ ./test_pointer.exe indices "/foo/bar"
+  [Mem:foo, Mem:bar]
+  $ ./test_pointer.exe indices "/foo/0/bar"
+  [Mem:foo, Nth:0, Mem:bar]
+  $ ./test_pointer.exe indices "/foo/-"
+  [Mem:foo]
+
+================================================================================
+Coercion Functions (any, is_nav, to_nav, to_nav_exn)
+================================================================================
+
+Note: is_nav is tested indirectly via the parse tests. Testing to_nav:
+
+  $ ./test_pointer.exe to-nav ""
+  Some()
+  $ ./test_pointer.exe to-nav "/foo"
+  Some(/foo)
+  $ ./test_pointer.exe to-nav "/foo/bar"
+  Some(/foo/bar)
+  $ ./test_pointer.exe to-nav "/-"
+  None
+  $ ./test_pointer.exe to-nav "/foo/-"
+  None
+
+Testing to_nav_exn:
+  $ ./test_pointer.exe to-nav-exn ""
+  OK: 
+  $ ./test_pointer.exe to-nav-exn "/foo"
+  OK: /foo
+  $ ./test_pointer.exe to-nav-exn "/-"
+  ERROR: JSON Pointer: cannot convert append pointer to nav pointer
+  $ ./test_pointer.exe to-nav-exn "/foo/-"
+  ERROR: JSON Pointer: cannot convert append pointer to nav pointer
+
+================================================================================
+Parsing Functions (of_string_kind, of_string_result, of_uri_fragment_nav, of_uri_fragment_result)
+================================================================================
+
+Testing of_string_kind:
+  $ ./test_pointer.exe of-string-kind ""
+  Nav()
+  $ ./test_pointer.exe of-string-kind "/foo"
+  Nav(/foo)
+  $ ./test_pointer.exe of-string-kind "/-"
+  Append(/-)
+  $ ./test_pointer.exe of-string-kind "/foo/-"
+  Append(/foo/-)
+  $ ./test_pointer.exe of-string-kind "/foo/bar"
+  Nav(/foo/bar)
+
+Testing of_string_result:
+  $ ./test_pointer.exe of-string-result ""
+  Ok()
+  $ ./test_pointer.exe of-string-result "/foo"
+  Ok(/foo)
+  $ ./test_pointer.exe of-string-result "/-"
+  Ok(/-)
+  $ ./test_pointer.exe of-string-result "invalid"
+  Error(Invalid JSON Pointer: must be empty or start with '/': invalid)
+  $ ./test_pointer.exe of-string-result "/~"
+  Error(Invalid JSON Pointer: incomplete escape sequence at end)
+
+Testing of_uri_fragment_nav:
+  $ ./test_pointer.exe of-uri-fragment-nav ""
+  OK: 
+  $ ./test_pointer.exe of-uri-fragment-nav "/foo"
+  OK: /foo
+  $ ./test_pointer.exe of-uri-fragment-nav "/foo/bar"
+  OK: /foo/bar
+  $ ./test_pointer.exe of-uri-fragment-nav "/foo%2Fbar"
+  OK: /foo/bar
+  $ ./test_pointer.exe of-uri-fragment-nav "/-"
+  ERROR: Invalid JSON Pointer: '-' not allowed in navigation pointer
+
+Testing of_uri_fragment_result:
+  $ ./test_pointer.exe of-uri-fragment-result ""
+  Ok()
+  $ ./test_pointer.exe of-uri-fragment-result "/foo"
+  Ok(/foo)
+  $ ./test_pointer.exe of-uri-fragment-result "/-"
+  Ok(/-)
+  $ ./test_pointer.exe of-uri-fragment-result "invalid"
+  Error(Invalid JSON Pointer: must be empty or start with '/': invalid)
+
+================================================================================
+Pretty Printing (pp, pp_verbose)
+================================================================================
+
+Testing pp:
+  $ ./test_pointer.exe pp ""
+  
+
+  $ ./test_pointer.exe pp "/foo"
+  /foo
+  $ ./test_pointer.exe pp "/foo/bar"
+  /foo/bar
+  $ ./test_pointer.exe pp "/-"
+  /-
+  $ ./test_pointer.exe pp "/foo/-"
+  /foo/-
+
+Testing pp_verbose:
+  $ ./test_pointer.exe pp-verbose ""
+  []
+  $ ./test_pointer.exe pp-verbose "/foo"
+  [Mem "foo"]
+  $ ./test_pointer.exe pp-verbose "/foo/0"
+  [Mem "foo"; Nth 0]
+  $ ./test_pointer.exe pp-verbose "/foo/bar/baz"
+  [Mem "foo"; Mem "bar"; Mem "baz"]
+  $ ./test_pointer.exe pp-verbose "/-"
+  [] /-
+  $ ./test_pointer.exe pp-verbose "/foo/-"
+  [Mem "foo"] /-
+
+================================================================================
+Comparison (equal, compare)
+================================================================================
+
+Testing equal:
+  $ ./test_pointer.exe equal "" ""
+  true
+  $ ./test_pointer.exe equal "/foo" "/foo"
+  true
+  $ ./test_pointer.exe equal "/foo" "/bar"
+  false
+  $ ./test_pointer.exe equal "/foo/0" "/foo/0"
+  true
+  $ ./test_pointer.exe equal "/foo/0" "/foo/1"
+  false
+  $ ./test_pointer.exe equal "/-" "/-"
+  true
+  $ ./test_pointer.exe equal "/foo/-" "/foo/-"
+  true
+  $ ./test_pointer.exe equal "/foo" "/foo/-"
+  false
+
+Testing compare:
+  $ ./test_pointer.exe compare "" ""
+  EQ
+  $ ./test_pointer.exe compare "/foo" "/foo"
+  EQ
+  $ ./test_pointer.exe compare "/aaa" "/bbb"
+  LT
+  $ ./test_pointer.exe compare "/bbb" "/aaa"
+  GT
+  $ ./test_pointer.exe compare "/foo" "/foo/bar"
+  LT
+  $ ./test_pointer.exe compare "/foo/bar" "/foo"
+  GT
+  $ ./test_pointer.exe compare "/foo" "/foo/-"
+  LT
+  $ ./test_pointer.exe compare "/foo/-" "/foo"
+  GT
+
+================================================================================
+Jsont.Path Conversion (of_path, to_path)
+================================================================================
+
+Testing of_path (builds a path programmatically):
+  $ ./test_pointer.exe of-path
+  /0/foo/1
+
+Testing to_path:
+  $ ./test_pointer.exe to-path ""
+  []
+  $ ./test_pointer.exe to-path "/foo"
+  [Mem:foo]
+  $ ./test_pointer.exe to-path "/foo/0"
+  [Mem:foo, Nth:0]
+  $ ./test_pointer.exe to-path "/a/b/c"
+  [Mem:a, Mem:b, Mem:c]
+
+================================================================================
+Evaluation (get_result, set)
+================================================================================
+
+Testing get_result:
+  $ ./test_pointer.exe get-result '{"foo":"bar"}' '/foo'
+  Ok("bar")
+  $ ./test_pointer.exe get-result '{"foo":{"bar":"baz"}}' '/foo/bar'
+  Ok("baz")
+  $ ./test_pointer.exe get-result '["a","b","c"]' '/1'
+  Ok("b")
+  $ ./test_pointer.exe get-result '{"foo":"bar"}' '/baz'
+  Error(JSON Pointer: member 'baz' not found
+  File "-":)
+  $ ./test_pointer.exe get-result '["a","b"]' '/5'
+  Error(JSON Pointer: index 5 out of bounds (array has 2 elements)
+  File "-":)
+
+Testing set (with nav pointer):
+  $ ./test_pointer.exe set '{"foo":"bar"}' '/foo' '"baz"'
+  {"foo":"baz"}
+  $ ./test_pointer.exe set '{"foo":{"bar":"old"}}' '/foo/bar' '"new"'
+  {"foo":{"bar":"new"}}
+  $ ./test_pointer.exe set '["a","b","c"]' '/1' '"x"'
+  ["a","x","c"]
+
+Testing set (with append pointer):
+  $ ./test_pointer.exe set '["a","b"]' '/-' '"c"'
+  ["a","b","c"]
+  $ ./test_pointer.exe set '{"arr":["x"]}' '/arr/-' '"y"'
+  {"arr":["x","y"]}
+
+================================================================================
+Jsont Codecs (jsont, jsont_kind, jsont_nav, jsont_uri_fragment)
+================================================================================
+
+Testing jsont codec roundtrip:
+  $ ./test_pointer.exe jsont-codec ""
+  ""
+  $ ./test_pointer.exe jsont-codec "/foo"
+  "/foo"
+  $ ./test_pointer.exe jsont-codec "/foo/bar"
+  "/foo/bar"
+  $ ./test_pointer.exe jsont-codec "/-"
+  "/-"
+  $ ./test_pointer.exe jsont-codec "/foo/-"
+  "/foo/-"
+
+Testing jsont_kind codec:
+  $ ./test_pointer.exe jsont-kind ""
+  Nav()
+  $ ./test_pointer.exe jsont-kind "/foo"
+  Nav(/foo)
+  $ ./test_pointer.exe jsont-kind "/-"
+  Append(/-)
+  $ ./test_pointer.exe jsont-kind "/foo/-"
+  Append(/foo/-)
+
+Testing jsont_nav codec:
+  $ ./test_pointer.exe jsont-nav ""
+  OK: 
+  $ ./test_pointer.exe jsont-nav "/foo"
+  OK: /foo
+  $ ./test_pointer.exe jsont-nav "/-"
+  ERROR: Invalid JSON Pointer: '-' not allowed in navigation pointer
+  $ ./test_pointer.exe jsont-nav "/foo/-"
+  ERROR: Invalid JSON Pointer: '-' not allowed in navigation pointer
+
+Testing jsont_uri_fragment codec:
+  $ ./test_pointer.exe jsont-uri-fragment ""
+  ""
+  $ ./test_pointer.exe jsont-uri-fragment "/foo"
+  "/foo"
+  $ ./test_pointer.exe jsont-uri-fragment "/a~1b"
+  "/a~1b"
+
+================================================================================
+Query Combinators (path, set_path, update_path, delete_path)
+================================================================================
+
+Testing path combinator:
+  $ ./test_pointer.exe query-path '{"name":"alice"}' '/name'
+  OK: alice
+  $ ./test_pointer.exe query-path '{"user":{"name":"bob"}}' '/user/name'
+  OK: bob
+
+Testing path combinator with absent:
+  $ ./test_pointer.exe query-path-absent '{"name":"alice"}' '/name' 'default'
+  OK: alice
+  $ ./test_pointer.exe query-path-absent '{"other":"value"}' '/name' 'default'
+  OK: default
+
+Testing set_path combinator:
+  $ ./test_pointer.exe set-path '{"name":"alice"}' '/name' 'bob'
+  {"name":"bob"}
+  $ ./test_pointer.exe set-path '{"user":{"name":"old"}}' '/user/name' 'new'
+  {"user":{"name":"new"}}
+
+Testing update_path combinator:
+  $ ./test_pointer.exe update-path '{"name":"alice"}' '/name'
+  {"name":"alice"}
+  $ ./test_pointer.exe update-path '{"user":{"name":"bob"}}' '/user/name'
+  {"user":{"name":"bob"}}
+
+Testing delete_path combinator:
+  $ ./test_pointer.exe delete-path '{"foo":"bar","baz":"qux"}' '/foo'
+  {"baz":"qux"}
+  $ ./test_pointer.exe delete-path '{"user":{"name":"bob","age":30}}' '/user/name'
+  {"user":{"age":30}}
+
+Testing delete_path with allow_absent:
+  $ ./test_pointer.exe delete-path-absent '{"foo":"bar"}' '/baz'
+  {"foo":"bar"}
+  $ ./test_pointer.exe delete-path-absent '{"foo":"bar"}' '/foo'
+  {}
+
+================================================================================
+JMAP Extended Pointers - Additional Tests
+================================================================================
+
+Testing Jmap.of_string_result:
+  $ ./test_pointer.exe jmap-of-string-result ""
+  Ok()
+  $ ./test_pointer.exe jmap-of-string-result "/foo"
+  Ok(/foo)
+  $ ./test_pointer.exe jmap-of-string-result "/*"
+  Ok(/*)
+  $ ./test_pointer.exe jmap-of-string-result "/list/*/id"
+  Ok(/list/*/id)
+  $ ./test_pointer.exe jmap-of-string-result "invalid"
+  Error(Invalid JMAP Pointer: must be empty or start with '/': invalid)
+  $ ./test_pointer.exe jmap-of-string-result "/-"
+  Error(Invalid JMAP Pointer: '-' not supported in result reference paths)
+
+Testing Jmap.pp:
+  $ ./test_pointer.exe jmap-pp ""
+  
+
+  $ ./test_pointer.exe jmap-pp "/foo"
+  /foo
+  $ ./test_pointer.exe jmap-pp "/*"
+  /*
+  $ ./test_pointer.exe jmap-pp "/list/*/id"
+  /list/*/id
+
+Testing Jmap.eval_result:
+  $ ./test_pointer.exe jmap-eval-result '{"foo":"bar"}' '/foo'
+  Ok("bar")
+  $ ./test_pointer.exe jmap-eval-result '{"list":[{"id":"a"},{"id":"b"}]}' '/list/*/id'
+  Ok(["a","b"])
+  $ ./test_pointer.exe jmap-eval-result '{"foo":"bar"}' '/baz'
+  Error(JMAP Pointer: member 'baz' not found
+  File "-":)
+
+Testing Jmap.find:
+  $ ./test_pointer.exe jmap-find '{"foo":"bar"}' '/foo'
+  Some("bar")
+  $ ./test_pointer.exe jmap-find '{"list":[{"id":"a"},{"id":"b"}]}' '/list/*/id'
+  Some(["a","b"])
+  $ ./test_pointer.exe jmap-find '{"foo":"bar"}' '/baz'
+  None
+  $ ./test_pointer.exe jmap-find '{"obj":{"a":1}}' '/obj/*'
+  None
+
+Testing Jmap.jsont codec:
+  $ ./test_pointer.exe jmap-jsont ""
+  ""
+  $ ./test_pointer.exe jmap-jsont "/foo"
+  "/foo"
+  $ ./test_pointer.exe jmap-jsont "/*"
+  "/*"
+  $ ./test_pointer.exe jmap-jsont "/list/*/id"
+  "/list/*/id"

test/test_pointer.ml

···
   | Ok s -> s
   | Error e -> failwith e
 
-(* Helper to get indices from either nav or append pointer *)
-let indices_of_result (result : [ `Nav of Jsont_pointer.nav Jsont_pointer.t
-                                | `Append of Jsont_pointer.append Jsont_pointer.t ]) =
-  match result with
-  | `Nav p -> Jsont_pointer.indices p
-  | `Append p -> Jsont_pointer.indices p
+(* Helper to get indices from any pointer *)
+let indices_of_any (Jsont_pointer.Any p) = Jsont_pointer.indices p
+
+(* Helper to convert to string from any pointer *)
+let to_string_of_any (Jsont_pointer.Any p) = Jsont_pointer.to_string p
 
-(* Helper to convert to string from either nav or append pointer *)
-let to_string_of_result (result : [ `Nav of Jsont_pointer.nav Jsont_pointer.t
-                                  | `Append of Jsont_pointer.append Jsont_pointer.t ]) =
-  match result with
-  | `Nav p -> Jsont_pointer.to_string p
-  | `Append p -> Jsont_pointer.to_string p
+(* Helper to check if pointer is append *)
+let is_append_any p = not (Jsont_pointer.is_nav p)
 
 (* Test: parse pointer and print indices *)
 let test_parse pointer_str =
   try
     let result = Jsont_pointer.of_string pointer_str in
-    let indices = indices_of_result result in
+    let indices = indices_of_any result in
     let index_strs = List.map (fun idx ->
       match idx with
       | Jsont.Path.Mem (s, _) -> Printf.sprintf "Mem:%s" s
       | Jsont.Path.Nth (n, _) -> Printf.sprintf "Nth:%d" n
     ) indices in
-    let suffix = match result with `Nav _ -> "" | `Append _ -> ", /-" in
+    let suffix = if is_append_any result then ", /-" else "" in
     Printf.printf "OK: [%s%s]\n" (String.concat ", " index_strs) suffix
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
 let test_roundtrip pointer_str =
   try
     let result = Jsont_pointer.of_string pointer_str in
-    let s = to_string_of_result result in
+    let s = to_string_of_any result in
     if s = pointer_str then
       Printf.printf "OK: %s\n" s
     else
···
 let test_uri_fragment pointer_str =
   try
     let result = Jsont_pointer.of_string pointer_str in
-    let frag = match result with
-      | `Nav p -> Jsont_pointer.to_uri_fragment p
-      | `Append p -> Jsont_pointer.to_uri_fragment p
-    in
+    let (Jsont_pointer.Any p) = result in
+    let frag = Jsont_pointer.to_uri_fragment p in
     let result2 = Jsont_pointer.of_uri_fragment frag in
-    let s2 = to_string_of_result result2 in
+    let s2 = to_string_of_any result2 in
     if s2 = pointer_str then
       Printf.printf "OK: %s -> %s\n" pointer_str frag
     else
···
   try
     let json = parse_json json_str in
     let value = parse_json value_str in
-    let result = match Jsont_pointer.of_string pointer_str with
-      | `Nav p -> Jsont_pointer.add p json ~value
-      | `Append p -> Jsont_pointer.add p json ~value
-    in
+    let p = Jsont_pointer.of_string pointer_str in
+    let result = Jsont_pointer.add p json ~value in
     Printf.printf "%s\n" (json_to_string result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
   try
     let json = parse_json json_str in
     let from = Jsont_pointer.of_string_nav from_str in
-    let result = match Jsont_pointer.of_string path_str with
-      | `Nav path -> Jsont_pointer.move ~from ~path json
-      | `Append path -> Jsont_pointer.move ~from ~path json
-    in
+    let path = Jsont_pointer.of_string path_str in
+    let result = Jsont_pointer.move ~from ~path json in
     Printf.printf "%s\n" (json_to_string result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
   try
     let json = parse_json json_str in
     let from = Jsont_pointer.of_string_nav from_str in
-    let result = match Jsont_pointer.of_string path_str with
-      | `Nav path -> Jsont_pointer.copy ~from ~path json
-      | `Append path -> Jsont_pointer.copy ~from ~path json
-    in
+    let path = Jsont_pointer.of_string path_str in
+    let result = Jsont_pointer.copy ~from ~path json in
     Printf.printf "%s\n" (json_to_string result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
   | Failure e ->
     Printf.printf "FAIL: %s\n" e
 
+(* Test: index functions - mem, nth, pp_index, equal_index, compare_index *)
+let test_mem name =
+  let idx = Jsont_pointer.mem name in
+  Format.printf "mem(%s) = %a\n" name Jsont_pointer.pp_index idx
+
+let test_nth n =
+  let idx = Jsont_pointer.nth n in
+  Format.printf "nth(%d) = %a\n" n Jsont_pointer.pp_index idx
+
+let test_equal_index idx1_str idx2_str =
+  let parse_idx s =
+    if String.length s > 0 && s.[0] >= '0' && s.[0] <= '9' then
+      Jsont_pointer.nth (int_of_string s)
+    else
+      Jsont_pointer.mem s
+  in
+  let idx1 = parse_idx idx1_str in
+  let idx2 = parse_idx idx2_str in
+  Printf.printf "%b\n" (Jsont_pointer.equal_index idx1 idx2)
+
+let test_compare_index idx1_str idx2_str =
+  let parse_idx s =
+    if String.length s > 0 && s.[0] >= '0' && s.[0] <= '9' then
+      Jsont_pointer.nth (int_of_string s)
+    else
+      Jsont_pointer.mem s
+  in
+  let idx1 = parse_idx idx1_str in
+  let idx2 = parse_idx idx2_str in
+  let cmp = Jsont_pointer.compare_index idx1 idx2 in
+  if cmp < 0 then Printf.printf "LT\n"
+  else if cmp > 0 then Printf.printf "GT\n"
+  else Printf.printf "EQ\n"
+
+(* Test: pointer constructors - root, is_root, make *)
+let test_root () =
+  let r = Jsont_pointer.root in
+  Printf.printf "root = %s\n" (Jsont_pointer.to_string r);
+  Printf.printf "is_root(root) = %b\n" (Jsont_pointer.is_root r)
+
+let test_is_root pointer_str =
+  try
+    let p = Jsont_pointer.of_string pointer_str in
+    let (Jsont_pointer.Any ptr) = p in
+    Printf.printf "%b\n" (Jsont_pointer.is_root ptr)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+let test_make indices_str =
+  (* Parse comma-separated indices like "foo,0,bar" *)
+  let parts = String.split_on_char ',' indices_str in
+  let indices = List.map (fun s ->
+    let s = String.trim s in
+    if s = "" then Jsont_pointer.mem ""
+    else if String.length s > 0 && s.[0] >= '0' && s.[0] <= '9' then
+      Jsont_pointer.nth (int_of_string s)
+    else
+      Jsont_pointer.mem s
+  ) parts in
+  let p = Jsont_pointer.make indices in
+  Printf.printf "%s\n" (Jsont_pointer.to_string p)
+
+(* Test: append_index and / operator *)
+let test_append_index base_str index_str =
+  try
+    let base = Jsont_pointer.of_string_nav base_str in
+    let idx =
+      if String.length index_str > 0 && index_str.[0] >= '0' && index_str.[0] <= '9' then
+        Jsont_pointer.nth (int_of_string index_str)
+      else
+        Jsont_pointer.mem index_str
+    in
+    let result = Jsont_pointer.(base / idx) in
+    Printf.printf "%s\n" (Jsont_pointer.to_string result)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: at_end *)
+let test_at_end pointer_str =
+  try
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    let append_p = Jsont_pointer.at_end p in
+    Printf.printf "%s\n" (Jsont_pointer.to_string append_p)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: concat *)
+let test_concat p1_str p2_str =
+  try
+    let p1 = Jsont_pointer.of_string_nav p1_str in
+    let p2 = Jsont_pointer.of_string_nav p2_str in
+    let result = Jsont_pointer.concat p1 p2 in
+    Printf.printf "%s\n" (Jsont_pointer.to_string result)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: parent *)
+let test_parent pointer_str =
+  try
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    match Jsont_pointer.parent p with
+    | Some parent -> Printf.printf "Some(%s)\n" (Jsont_pointer.to_string parent)
+    | None -> Printf.printf "None\n"
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: last *)
+let test_last pointer_str =
+  try
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    match Jsont_pointer.last p with
+    | Some idx -> Format.printf "Some(%a)\n" Jsont_pointer.pp_index idx
+    | None -> Printf.printf "None\n"
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: indices *)
+let test_indices pointer_str =
+  try
+    let p = Jsont_pointer.of_string pointer_str in
+    let indices = indices_of_any p in
+    let strs = List.map (fun idx ->
+      match idx with
+      | Jsont.Path.Mem (s, _) -> Printf.sprintf "Mem:%s" s
+      | Jsont.Path.Nth (n, _) -> Printf.sprintf "Nth:%d" n
+    ) indices in
+    Printf.printf "[%s]\n" (String.concat ", " strs)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: coercion - to_nav, to_nav_exn *)
+let test_to_nav pointer_str =
+  try
+    let p = Jsont_pointer.of_string pointer_str in
+    match Jsont_pointer.to_nav p with
+    | Some nav -> Printf.printf "Some(%s)\n" (Jsont_pointer.to_string nav)
+    | None -> Printf.printf "None\n"
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+let test_to_nav_exn pointer_str =
+  try
+    let p = Jsont_pointer.of_string pointer_str in
+    let nav = Jsont_pointer.to_nav_exn p in
+    Printf.printf "OK: %s\n" (Jsont_pointer.to_string nav)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: of_string_kind *)
+let test_of_string_kind pointer_str =
+  try
+    match Jsont_pointer.of_string_kind pointer_str with
+    | `Nav p -> Printf.printf "Nav(%s)\n" (Jsont_pointer.to_string p)
+    | `Append p -> Printf.printf "Append(%s)\n" (Jsont_pointer.to_string p)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: of_string_result *)
+let test_of_string_result pointer_str =
+  match Jsont_pointer.of_string_result pointer_str with
+  | Ok p -> Printf.printf "Ok(%s)\n" (to_string_of_any p)
+  | Error e -> Printf.printf "Error(%s)\n" e
+
+(* Test: of_uri_fragment_nav *)
+let test_of_uri_fragment_nav frag =
+  try
+    let p = Jsont_pointer.of_uri_fragment_nav frag in
+    Printf.printf "OK: %s\n" (Jsont_pointer.to_string p)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: of_uri_fragment_result *)
+let test_of_uri_fragment_result frag =
+  match Jsont_pointer.of_uri_fragment_result frag with
+  | Ok p -> Printf.printf "Ok(%s)\n" (to_string_of_any p)
+  | Error e -> Printf.printf "Error(%s)\n" e
+
+(* Test: pp and pp_verbose *)
+let test_pp pointer_str =
+  try
+    let p = Jsont_pointer.of_string pointer_str in
+    let (Jsont_pointer.Any ptr) = p in
+    Format.printf "%a\n" Jsont_pointer.pp ptr
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+let test_pp_verbose pointer_str =
+  try
+    let p = Jsont_pointer.of_string pointer_str in
+    let (Jsont_pointer.Any ptr) = p in
+    Format.printf "%a\n" Jsont_pointer.pp_verbose ptr
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: equal *)
+let test_equal p1_str p2_str =
+  try
+    let p1 = Jsont_pointer.of_string p1_str in
+    let p2 = Jsont_pointer.of_string p2_str in
+    let (Jsont_pointer.Any ptr1) = p1 in
+    let (Jsont_pointer.Any ptr2) = p2 in
+    Printf.printf "%b\n" (Jsont_pointer.equal ptr1 ptr2)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: compare *)
+let test_compare p1_str p2_str =
+  try
+    let p1 = Jsont_pointer.of_string p1_str in
+    let p2 = Jsont_pointer.of_string p2_str in
+    let (Jsont_pointer.Any ptr1) = p1 in
+    let (Jsont_pointer.Any ptr2) = p2 in
+    let cmp = Jsont_pointer.compare ptr1 ptr2 in
+    if cmp < 0 then Printf.printf "LT\n"
+    else if cmp > 0 then Printf.printf "GT\n"
+    else Printf.printf "EQ\n"
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: of_path and to_path *)
+let test_of_path () =
+  (* Create a Jsont.Path and convert to pointer *)
+  let path = Jsont.Path.(
+    root
+    |> Jsont.Path.nth 0
+    |> Jsont.Path.mem "foo"
+    |> Jsont.Path.nth 1
+  ) in
+  let p = Jsont_pointer.of_path path in
+  Printf.printf "%s\n" (Jsont_pointer.to_string p)
+
+let test_to_path pointer_str =
+  try
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    let path = Jsont_pointer.to_path p in
+    (* Use rev_indices to get the indices in reverse order *)
+    let indices = Jsont.Path.rev_indices path in
+    let parts = List.rev_map (fun idx ->
+      match idx with
+      | Jsont.Path.Mem (s, _) -> Printf.sprintf "Mem:%s" s
+      | Jsont.Path.Nth (n, _) -> Printf.sprintf "Nth:%d" n
+    ) indices in
+    Printf.printf "[%s]\n" (String.concat ", " parts)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: get_result *)
+let test_get_result json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    match Jsont_pointer.get_result p json with
+    | Ok result -> Printf.printf "Ok(%s)\n" (json_to_string result)
+    | Error e -> Printf.printf "Error(%s)\n" (Jsont.Error.to_string e)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: set operation *)
+let test_set json_str pointer_str value_str =
+  try
+    let json = parse_json json_str in
+    let value = parse_json value_str in
+    let p = Jsont_pointer.of_string pointer_str in
+    let result = Jsont_pointer.set p json ~value in
+    Printf.printf "%s\n" (json_to_string result)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: jsont codec *)
+let test_jsont_codec pointer_str =
+  try
+    let json = Jsont.Json.string pointer_str in
+    let decoded = match Jsont.Json.decode' Jsont_pointer.jsont json with
+      | Ok p -> p
+      | Error e -> raise (Jsont.Error e)
+    in
+    let encoded = match Jsont.Json.encode' Jsont_pointer.jsont decoded with
+      | Ok j -> j
+      | Error e -> raise (Jsont.Error e)
+    in
+    let encoded_str = json_to_string encoded in
+    Printf.printf "%s\n" encoded_str
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: jsont_kind codec *)
+let test_jsont_kind pointer_str =
+  try
+    let json = Jsont.Json.string pointer_str in
+    let decoded = match Jsont.Json.decode' Jsont_pointer.jsont_kind json with
+      | Ok p -> p
+      | Error e -> raise (Jsont.Error e)
+    in
+    match decoded with
+    | `Nav p -> Printf.printf "Nav(%s)\n" (Jsont_pointer.to_string p)
+    | `Append p -> Printf.printf "Append(%s)\n" (Jsont_pointer.to_string p)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: jsont_nav codec *)
+let test_jsont_nav pointer_str =
+  try
+    let json = Jsont.Json.string pointer_str in
+    let decoded = match Jsont.Json.decode' Jsont_pointer.jsont_nav json with
+      | Ok p -> p
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "OK: %s\n" (Jsont_pointer.to_string decoded)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: jsont_uri_fragment codec *)
+let test_jsont_uri_fragment pointer_str =
+  try
+    (* First parse it normally, then encode as URI fragment *)
+    let p = Jsont_pointer.of_string pointer_str in
+    let encoded = match Jsont.Json.encode' Jsont_pointer.jsont_uri_fragment p with
+      | Ok j -> j
+      | Error e -> raise (Jsont.Error e)
+    in
+    let encoded_str = json_to_string encoded in
+    Printf.printf "%s\n" encoded_str
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: query combinator - path *)
+let test_query_path json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    let codec = Jsont_pointer.path p Jsont.string in
+    let result = match Jsont.Json.decode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "OK: %s\n" result
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: query combinator - path with absent *)
+let test_query_path_absent json_str pointer_str default =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    let codec = Jsont_pointer.path ~absent:default p Jsont.string in
+    let result = match Jsont.Json.decode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "OK: %s\n" result
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: query combinator - set_path *)
+let test_set_path json_str pointer_str value_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.of_string pointer_str in
+    let codec = Jsont_pointer.set_path Jsont.string p value_str in
+    let result = match Jsont.Json.recode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "%s\n" (json_to_string result)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: query combinator - update_path *)
+let test_update_path json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    let codec = Jsont_pointer.update_path p Jsont.string in
+    let result = match Jsont.Json.recode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "%s\n" (json_to_string result)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: query combinator - delete_path *)
+let test_delete_path json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    let codec = Jsont_pointer.delete_path p in
+    let result = match Jsont.Json.recode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "%s\n" (json_to_string result)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: query combinator - delete_path with allow_absent *)
+let test_delete_path_absent json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.of_string_nav pointer_str in
+    let codec = Jsont_pointer.delete_path ~allow_absent:true p in
+    let result = match Jsont.Json.recode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "%s\n" (json_to_string result)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: JMAP of_string_result *)
+let test_jmap_of_string_result pointer_str =
+  match Jsont_pointer.Jmap.of_string_result pointer_str with
+  | Ok p -> Printf.printf "Ok(%s)\n" (Jsont_pointer.Jmap.to_string p)
+  | Error e -> Printf.printf "Error(%s)\n" e
+
+(* Test: JMAP pp *)
+let test_jmap_pp pointer_str =
+  try
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    Format.printf "%a\n" Jsont_pointer.Jmap.pp p
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: JMAP eval_result *)
+let test_jmap_eval_result json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    match Jsont_pointer.Jmap.eval_result p json with
+    | Ok result -> Printf.printf "Ok(%s)\n" (json_to_string result)
+    | Error e -> Printf.printf "Error(%s)\n" (Jsont.Error.to_string e)
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: JMAP find *)
+let test_jmap_find json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    match Jsont_pointer.Jmap.find p json with
+    | Some result -> Printf.printf "Some(%s)\n" (json_to_string result)
+    | None -> Printf.printf "None\n"
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: JMAP jsont codec *)
+let test_jmap_jsont pointer_str =
+  try
+    let json = Jsont.Json.string pointer_str in
+    let decoded = match Jsont.Json.decode' Jsont_pointer.Jmap.jsont json with
+      | Ok p -> p
+      | Error e -> raise (Jsont.Error e)
+    in
+    let encoded = match Jsont.Json.encode' Jsont_pointer.Jmap.jsont decoded with
+      | Ok j -> j
+      | Error e -> raise (Jsont.Error e)
+    in
+    let encoded_str = json_to_string encoded in
+    Printf.printf "%s\n" encoded_str
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
 let () =
   match Array.to_list Sys.argv with
   | _ :: "parse" :: pointer :: _ ->
···
     test_jmap_path_single json pointer
   | _ :: "jmap-path-absent" :: json :: pointer :: default :: _ ->
     test_jmap_path_absent json pointer default
+  (* Index functions *)
+  | _ :: "mem" :: name :: _ ->
+    test_mem name
+  | _ :: "nth" :: n :: _ ->
+    test_nth (int_of_string n)
+  | _ :: "equal-index" :: idx1 :: idx2 :: _ ->
+    test_equal_index idx1 idx2
+  | _ :: "compare-index" :: idx1 :: idx2 :: _ ->
+    test_compare_index idx1 idx2
+  (* Pointer constructors *)
+  | _ :: "root" :: _ ->
+    test_root ()
+  | _ :: "is-root" :: pointer :: _ ->
+    test_is_root pointer
+  | _ :: "make" :: indices :: _ ->
+    test_make indices
+  | _ :: "append-index" :: base :: index :: _ ->
+    test_append_index base index
+  | _ :: "at-end" :: pointer :: _ ->
+    test_at_end pointer
+  | _ :: "concat" :: p1 :: p2 :: _ ->
+    test_concat p1 p2
+  | _ :: "parent" :: pointer :: _ ->
+    test_parent pointer
+  | _ :: "last" :: pointer :: _ ->
+    test_last pointer
+  | _ :: "indices" :: pointer :: _ ->
+    test_indices pointer
+  (* Coercion *)
+  | _ :: "to-nav" :: pointer :: _ ->
+    test_to_nav pointer
+  | _ :: "to-nav-exn" :: pointer :: _ ->
+    test_to_nav_exn pointer
+  (* Parsing variants *)
+  | _ :: "of-string-kind" :: pointer :: _ ->
+    test_of_string_kind pointer
+  | _ :: "of-string-result" :: pointer :: _ ->
+    test_of_string_result pointer
+  | _ :: "of-uri-fragment-nav" :: frag :: _ ->
+    test_of_uri_fragment_nav frag
+  | _ :: "of-uri-fragment-result" :: frag :: _ ->
+    test_of_uri_fragment_result frag
+  (* Pretty printing *)
+  | _ :: "pp" :: pointer :: _ ->
+    test_pp pointer
+  | _ :: "pp-verbose" :: pointer :: _ ->
+    test_pp_verbose pointer
+  (* Comparison *)
+  | _ :: "equal" :: p1 :: p2 :: _ ->
+    test_equal p1 p2
+  | _ :: "compare" :: p1 :: p2 :: _ ->
+    test_compare p1 p2
+  (* Path conversion *)
+  | _ :: "of-path" :: _ ->
+    test_of_path ()
+  | _ :: "to-path" :: pointer :: _ ->
+    test_to_path pointer
+  (* Evaluation *)
+  | _ :: "get-result" :: json :: pointer :: _ ->
+    test_get_result json pointer
+  | _ :: "set" :: json :: pointer :: value :: _ ->
+    test_set json pointer value
+  (* Jsont codecs *)
+  | _ :: "jsont-codec" :: pointer :: _ ->
+    test_jsont_codec pointer
+  | _ :: "jsont-kind" :: pointer :: _ ->
+    test_jsont_kind pointer
+  | _ :: "jsont-nav" :: pointer :: _ ->
+    test_jsont_nav pointer
+  | _ :: "jsont-uri-fragment" :: pointer :: _ ->
+    test_jsont_uri_fragment pointer
+  (* Query combinators *)
+  | _ :: "query-path" :: json :: pointer :: _ ->
+    test_query_path json pointer
+  | _ :: "query-path-absent" :: json :: pointer :: default :: _ ->
+    test_query_path_absent json pointer default
+  | _ :: "set-path" :: json :: pointer :: value :: _ ->
+    test_set_path json pointer value
+  | _ :: "update-path" :: json :: pointer :: _ ->
+    test_update_path json pointer
+  | _ :: "delete-path" :: json :: pointer :: _ ->
+    test_delete_path json pointer
+  | _ :: "delete-path-absent" :: json :: pointer :: _ ->
+    test_delete_path_absent json pointer
+  (* JMAP extras *)
+  | _ :: "jmap-of-string-result" :: pointer :: _ ->
+    test_jmap_of_string_result pointer
+  | _ :: "jmap-pp" :: pointer :: _ ->
+    test_jmap_pp pointer
+  | _ :: "jmap-eval-result" :: json :: pointer :: _ ->
+    test_jmap_eval_result json pointer
+  | _ :: "jmap-find" :: json :: pointer :: _ ->
+    test_jmap_find json pointer
+  | _ :: "jmap-jsont" :: pointer :: _ ->
+    test_jmap_jsont pointer
   | _ ->
     Printf.printf "Usage:\n";
     Printf.printf "  test_pointer parse <pointer>\n";
···
     Printf.printf "  test_pointer jmap-parse <pointer>\n";
     Printf.printf "  test_pointer jmap-eval <json> <pointer>\n";
     Printf.printf "  test_pointer jmap-eval-file <json-file> <pointer>\n";
+    Printf.printf "  -- Index functions --\n";
+    Printf.printf "  test_pointer mem <name>\n";
+    Printf.printf "  test_pointer nth <n>\n";
+    Printf.printf "  test_pointer equal-index <idx1> <idx2>\n";
+    Printf.printf "  test_pointer compare-index <idx1> <idx2>\n";
+    Printf.printf "  -- Pointer constructors --\n";
+    Printf.printf "  test_pointer root\n";
+    Printf.printf "  test_pointer is-root <pointer>\n";
+    Printf.printf "  test_pointer make <indices>\n";
+    Printf.printf "  test_pointer append-index <base> <index>\n";
+    Printf.printf "  test_pointer at-end <pointer>\n";
+    Printf.printf "  test_pointer concat <p1> <p2>\n";
+    Printf.printf "  test_pointer parent <pointer>\n";
+    Printf.printf "  test_pointer last <pointer>\n";
+    Printf.printf "  test_pointer indices <pointer>\n";
+    Printf.printf "  -- Coercion --\n";
+    Printf.printf "  test_pointer to-nav <pointer>\n";
+    Printf.printf "  test_pointer to-nav-exn <pointer>\n";
+    Printf.printf "  -- Parsing variants --\n";
+    Printf.printf "  test_pointer of-string-kind <pointer>\n";
+    Printf.printf "  test_pointer of-string-result <pointer>\n";
+    Printf.printf "  test_pointer of-uri-fragment-nav <frag>\n";
+    Printf.printf "  test_pointer of-uri-fragment-result <frag>\n";
+    Printf.printf "  -- Pretty printing --\n";
+    Printf.printf "  test_pointer pp <pointer>\n";
+    Printf.printf "  test_pointer pp-verbose <pointer>\n";
+    Printf.printf "  -- Comparison --\n";
+    Printf.printf "  test_pointer equal <p1> <p2>\n";
+    Printf.printf "  test_pointer compare <p1> <p2>\n";
+    Printf.printf "  -- Path conversion --\n";
+    Printf.printf "  test_pointer of-path\n";
+    Printf.printf "  test_pointer to-path <pointer>\n";
+    Printf.printf "  -- Evaluation --\n";
+    Printf.printf "  test_pointer get-result <json> <pointer>\n";
+    Printf.printf "  test_pointer set <json> <pointer> <value>\n";
+    Printf.printf "  -- Jsont codecs --\n";
+    Printf.printf "  test_pointer jsont-codec <pointer>\n";
+    Printf.printf "  test_pointer jsont-kind <pointer>\n";
+    Printf.printf "  test_pointer jsont-nav <pointer>\n";
+    Printf.printf "  test_pointer jsont-uri-fragment <pointer>\n";
+    Printf.printf "  -- Query combinators --\n";
+    Printf.printf "  test_pointer query-path <json> <pointer>\n";
+    Printf.printf "  test_pointer query-path-absent <json> <pointer> <default>\n";
+    Printf.printf "  test_pointer set-path <json> <pointer> <value>\n";
+    Printf.printf "  test_pointer update-path <json> <pointer>\n";
+    Printf.printf "  test_pointer delete-path <json> <pointer>\n";
+    Printf.printf "  test_pointer delete-path-absent <json> <pointer>\n";
+    Printf.printf "  -- JMAP extras --\n";
+    Printf.printf "  test_pointer jmap-of-string-result <pointer>\n";
+    Printf.printf "  test_pointer jmap-pp <pointer>\n";
+    Printf.printf "  test_pointer jmap-eval-result <json> <pointer>\n";
+    Printf.printf "  test_pointer jmap-find <json> <pointer>\n";
+    Printf.printf "  test_pointer jmap-jsont <pointer>\n";
     exit 1