rename to json-pointer

bin/dune

···
 (executable
  (name jsonpp)
  (public_name jsonpp)
- (package jsont-pointer)
- (libraries jsont jsont.bytesrw jsont_pointer))
+ (package json-pointer)
+ (libraries jsont jsont.bytesrw json_pointer))

bin/jsonpp.ml

···
-(* Test runner for jsont_pointer *)
+(* Test runner for json_pointer *)
 
 let read_file path =
   let ic = open_in path in
···
   | Error e -> failwith e
 
 (* Helper to get indices from any pointer *)
-let indices_of_any (Jsont_pointer.Any p) = Jsont_pointer.indices p
+let indices_of_any (Json_pointer.Any p) = Json_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
+let to_string_of_any (Json_pointer.Any p) = Json_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))
+let is_append_any (Json_pointer.Any p : Json_pointer.any) =
+  not (Json_pointer.is_nav (Json_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 result = Json_pointer.of_string pointer_str in
     let indices = indices_of_any result in
     let index_strs = List.map (fun idx ->
       match idx with
···
 (* Test: roundtrip pointer string *)
 let test_roundtrip pointer_str =
   try
-    let result = Jsont_pointer.of_string pointer_str in
+    let result = Json_pointer.of_string pointer_str in
     let s = to_string_of_any result in
     if s = pointer_str then
       Printf.printf "OK: %s\n" s
···
 let test_eval json_path pointer_str =
   try
     let json = parse_json (read_file json_path) in
-    let p = Jsont_pointer.of_string_nav pointer_str in
-    let result = Jsont_pointer.get p json in
+    let p = Json_pointer.of_string_nav pointer_str in
+    let result = Json_pointer.get p json in
     Printf.printf "OK: %s\n" (json_to_string result)
   with
   | Jsont.Error e ->
···
 
 (* Test: escape token *)
 let test_escape token =
-  let escaped = Jsont_pointer.Token.escape token in
+  let escaped = Json_pointer.Token.escape token in
   Printf.printf "%s\n" escaped
 
 (* Test: unescape token *)
 let test_unescape token =
   try
-    let unescaped = Jsont_pointer.Token.unescape token in
+    let unescaped = Json_pointer.Token.unescape token in
     Printf.printf "OK: %s\n" unescaped
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
 (* Test: URI fragment roundtrip *)
 let test_uri_fragment pointer_str =
   try
-    let result = Jsont_pointer.of_string pointer_str 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 result = Json_pointer.of_string pointer_str in
+    let (Json_pointer.Any p) = result in
+    let frag = Json_pointer.to_uri_fragment p in
+    let result2 = Json_pointer.of_uri_fragment frag in
     let s2 = to_string_of_any result2 in
     if s2 = pointer_str then
       Printf.printf "OK: %s -> %s\n" pointer_str frag
···
   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.add p json ~value in
+    let p = Json_pointer.of_string pointer_str in
+    let result = Json_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)
···
 let test_remove json_str pointer_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.of_string_nav pointer_str in
-    let result = Jsont_pointer.remove p json in
+    let p = Json_pointer.of_string_nav pointer_str in
+    let result = Json_pointer.remove p json in
     Printf.printf "%s\n" (json_to_string result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
 let test_replace json_str pointer_str value_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.of_string_nav pointer_str in
+    let p = Json_pointer.of_string_nav pointer_str in
     let value = parse_json value_str in
-    let result = Jsont_pointer.replace p json ~value in
+    let result = Json_pointer.replace 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)
···
 let test_move json_str from_str path_str =
   try
     let json = parse_json json_str in
-    let from = Jsont_pointer.of_string_nav from_str in
-    let path = Jsont_pointer.of_string path_str in
-    let result = Jsont_pointer.move ~from ~path json in
+    let from = Json_pointer.of_string_nav from_str in
+    let path = Json_pointer.of_string path_str in
+    let result = Json_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)
···
 let test_copy json_str from_str path_str =
   try
     let json = parse_json json_str in
-    let from = Jsont_pointer.of_string_nav from_str in
-    let path = Jsont_pointer.of_string path_str in
-    let result = Jsont_pointer.copy ~from ~path json in
+    let from = Json_pointer.of_string_nav from_str in
+    let path = Json_pointer.of_string path_str in
+    let result = Json_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)
···
 let test_test json_str pointer_str expected_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.of_string_nav pointer_str in
+    let p = Json_pointer.of_string_nav pointer_str in
     let expected = parse_json expected_str in
-    let result = Jsont_pointer.test p json ~expected in
+    let result = Json_pointer.test p json ~expected in
     Printf.printf "%b\n" result
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
 let test_has json_str pointer_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.of_string_nav pointer_str in
-    let result = Jsont_pointer.find p json in
+    let p = Json_pointer.of_string_nav pointer_str in
+    let result = Json_pointer.find p json in
     Printf.printf "%b\n" (Option.is_some result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

doc/dune

···
 (mdx
  (files tutorial.mld)
- (libraries jsont jsont.bytesrw jsont_pointer jsont_pointer_top))
+ (libraries jsont jsont.bytesrw json_pointer json_pointer_top))
 
 (documentation
- (package jsont-pointer)
+ (package json-pointer)
  (mld_files index tutorial))

doc/index.mld

···
-{0 jsont-pointer}
+{0 json-pointer}
 
-{!modules: Jsont_pointer Jsont_pointer_top}
+{!modules: Json_pointer Json_pointer_top}
 
 {1 Tutorial}
 

doc/tutorial.mld

···
 
 This tutorial introduces JSON Pointer as defined in
 {{:https://www.rfc-editor.org/rfc/rfc6901} RFC 6901}, and demonstrates
-the [jsont-pointer] OCaml library through interactive examples.
+the [json-pointer] OCaml library through interactive examples.
 
 {1 JSON Pointer vs JSON Path}
 
···
 (like JSON Schema's [$ref]). Use JSON Path when you might need multiple
 results (like Kubernetes queries).
 
-The [jsont-pointer] library implements JSON Pointer and integrates with
+The [json-pointer] library implements JSON Pointer and integrates with
 the {!Jsont.Path} type for representing navigation indices.
 
 {1 Setup}
 
 First, let's set up our environment. In the toplevel, you can load the
-library with [#require "jsont-pointer.top";;] which will automatically
+library with [#require "json-pointer.top";;] which will automatically
 install pretty printers.
 
 {@ocaml[
-# Jsont_pointer_top.install ();;
+# Json_pointer_top.install ();;
 - : unit = ()
-# open Jsont_pointer;;
+# open Json_pointer;;
 # let parse_json s =
     match Jsont_bytesrw.decode_string Jsont.json s with
     | Ok json -> json
···
 - : Jsont.json = "Alice"
 ]}
 
-In OCaml, this is represented by the ['a Jsont_pointer.t] type - a sequence
+In OCaml, this is represented by the ['a Json_pointer.t] type - a sequence
 of navigation steps from the document root to a target value. The phantom
 type parameter ['a] encodes whether this is a navigation pointer or an
 append pointer (more on this later).
···
 
 {2 Navigation vs Append Pointers}
 
-The [jsont-pointer] library uses {b phantom types} to encode the difference
+The [json-pointer] library uses {b phantom types} to encode the difference
 between pointers that can be used for navigation and pointers that target
 the "append position":
 
···
 {1 Mutation Operations}
 
 While RFC 6901 defines JSON Pointer for read-only access, RFC 6902
-(JSON Patch) uses JSON Pointer for modifications. The [jsont-pointer]
+(JSON Patch) uses JSON Pointer for modifications. The [json-pointer]
 library provides these operations.
 
 {2 Add}
···
 
 {2 The Library Handles Escaping Automatically}
 
-{b Important}: When using [jsont-pointer] programmatically, you rarely need
+{b Important}: When using [json-pointer] programmatically, you rarely need
 to think about escaping. The [Mem] variant stores unescaped strings,
 and escaping happens automatically during serialization:
 
···
 {- {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
+The [json-pointer] library implements all of this with type-safe OCaml
 interfaces, integration with the [jsont] codec system, and proper error
 handling for malformed pointers and missing values.
 

dune-project

···
 (lang dune 3.20)
 (using mdx 0.4)
 
-(name jsont-pointer)
+(name json-pointer)
 
 (generate_opam_files true)
 
···
 (maintenance_intent "(latest)")
 
 (package
- (name jsont-pointer)
+ (name json-pointer)
  (synopsis "RFC 6901 JSON Pointer implementation for jsont")
  (description
   "This library provides RFC 6901 JSON Pointer parsing, serialization, \

src/dune

···
 (library
- (name jsont_pointer)
- (public_name jsont-pointer)
+ (name json_pointer)
+ (public_name json-pointer)
  (libraries jsont))

src/top/dune

···
 (library
- (name jsont_pointer_top)
- (public_name jsont-pointer.top)
- (libraries jsont-pointer jsont.bytesrw compiler-libs))
+ (name json_pointer_top)
+ (public_name json-pointer.top)
+ (libraries json-pointer jsont.bytesrw compiler-libs))

src/top/jsont_pointer_top.ml src/top/json_pointer_top.ml

···
-(* Toplevel printers for Jsont_pointer.t, Jsont.json, and Jsont.Error.t
+(* Toplevel printers for Json_pointer.t, Jsont.json, and Jsont.Error.t
 
    Usage in toplevel:
-     #require "jsont-pointer.top";;
+     #require "json-pointer.top";;
 
    Printers are automatically installed when the library is loaded.
 *)
 
-let nav_printer ppf (p : Jsont_pointer.nav Jsont_pointer.t) =
-  Jsont_pointer.pp_verbose ppf p
+let nav_printer ppf (p : Json_pointer.nav Json_pointer.t) =
+  Json_pointer.pp_verbose ppf p
 
-let append_printer ppf (p : Jsont_pointer.append Jsont_pointer.t) =
-  Jsont_pointer.pp_verbose ppf p
+let append_printer ppf (p : Json_pointer.append Json_pointer.t) =
+  Json_pointer.pp_verbose ppf p
 
 let json_printer ppf (json : Jsont.json) =
   match Jsont_bytesrw.encode_string Jsont.json json with
···
 (* Automatic printer installation *)
 
 let printers =
-  [ "Jsont_pointer_top.nav_printer";
-    "Jsont_pointer_top.append_printer";
-    "Jsont_pointer_top.json_printer";
-    "Jsont_pointer_top.error_printer" ]
+  [ "Json_pointer_top.nav_printer";
+    "Json_pointer_top.append_printer";
+    "Json_pointer_top.json_printer";
+    "Json_pointer_top.error_printer" ]
 
 (* Suppress stderr during printer installation to avoid noise in MDX tests *)
 let null_formatter = Format.make_formatter (fun _ _ _ -> ()) (fun () -> ())

src/top/jsont_pointer_top.mli src/top/json_pointer_top.mli

···
-(** Toplevel printers for {!Jsont_pointer}, {!Jsont.json}, and {!Jsont.Error.t}.
+(** Toplevel printers for {!Json_pointer}, {!Jsont.json}, and {!Jsont.Error.t}.
 
     Printers are automatically installed when the library is loaded:
     {[
-      #require "jsont-pointer.top";;
+      #require "json-pointer.top";;
     ]}
 
     After loading, JSON Pointers will display their structure:
     {[
-      # Jsont_pointer.of_string_nav "/foo/0";;
-      - : Jsont_pointer.nav Jsont_pointer.t = [Mem "foo"; Nth 0]
+      # Json_pointer.of_string_nav "/foo/0";;
+      - : Json_pointer.nav Json_pointer.t = [Mem "foo"; Nth 0]
     ]}
 
     JSON values will display as formatted JSON strings:
···
 
     And errors will display as readable messages:
     {[
-      # Jsont_pointer.of_string "invalid";;
+      # Json_pointer.of_string "invalid";;
       Exception: Jsont.Error: Invalid JSON Pointer: must be empty or start with '/'
     ]} *)
 
-val nav_printer : Format.formatter -> Jsont_pointer.nav Jsont_pointer.t -> unit
+val nav_printer : Format.formatter -> Json_pointer.nav Json_pointer.t -> unit
 (** [nav_printer] formats a navigation JSON Pointer showing its index structure.
     Suitable for use with [#install_printer]. *)
 
-val append_printer : Format.formatter -> Jsont_pointer.append Jsont_pointer.t -> unit
+val append_printer : Format.formatter -> Json_pointer.append Json_pointer.t -> unit
 (** [append_printer] formats an append JSON Pointer showing its index structure.
     Suitable for use with [#install_printer]. *)
 

test/api.t

···
 JSON Pointer API Test Suite
 
-This tests all functions exposed in jsont_pointer.mli.
+This tests all functions exposed in json_pointer.mli.
 
 ================================================================================
 Index Functions (mem, nth, pp_index, equal_index, compare_index)

test/dune

···
 (executable
  (name test_pointer)
- (libraries jsont jsont.bytesrw jsont_pointer))
+ (libraries jsont jsont.bytesrw json_pointer))
 
 (cram
  (deps test_pointer.exe

test/test_pointer.ml

···
-(* Test runner for jsont_pointer *)
+(* Test runner for json_pointer *)
 
 let read_file path =
   let ic = open_in path in
···
   | Error e -> failwith e
 
 (* Helper to get indices from any pointer *)
-let indices_of_any (Jsont_pointer.Any p) = Jsont_pointer.indices p
+let indices_of_any (Json_pointer.Any p) = Json_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
+let to_string_of_any (Json_pointer.Any p) = Json_pointer.to_string p
 
 (* Helper to check if pointer is append *)
-let is_append_any p = not (Jsont_pointer.is_nav p)
+let is_append_any p = not (Json_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 result = Json_pointer.of_string pointer_str in
     let indices = indices_of_any result in
     let index_strs = List.map (fun idx ->
       match idx with
···
 (* Test: roundtrip pointer string *)
 let test_roundtrip pointer_str =
   try
-    let result = Jsont_pointer.of_string pointer_str in
+    let result = Json_pointer.of_string pointer_str in
     let s = to_string_of_any result in
     if s = pointer_str then
       Printf.printf "OK: %s\n" s
···
 let test_eval json_path pointer_str =
   try
     let json = parse_json (read_file json_path) in
-    let p = Jsont_pointer.of_string_nav pointer_str in
-    let result = Jsont_pointer.get p json in
+    let p = Json_pointer.of_string_nav pointer_str in
+    let result = Json_pointer.get p json in
     Printf.printf "OK: %s\n" (json_to_string result)
   with
   | Jsont.Error e ->
···
 
 (* Test: escape token *)
 let test_escape token =
-  let escaped = Jsont_pointer.Token.escape token in
+  let escaped = Json_pointer.Token.escape token in
   Printf.printf "%s\n" escaped
 
 (* Test: unescape token *)
 let test_unescape token =
   try
-    let unescaped = Jsont_pointer.Token.unescape token in
+    let unescaped = Json_pointer.Token.unescape token in
     Printf.printf "OK: %s\n" unescaped
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
 (* Test: URI fragment roundtrip *)
 let test_uri_fragment pointer_str =
   try
-    let result = Jsont_pointer.of_string pointer_str 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 result = Json_pointer.of_string pointer_str in
+    let (Json_pointer.Any p) = result in
+    let frag = Json_pointer.to_uri_fragment p in
+    let result2 = Json_pointer.of_uri_fragment frag in
     let s2 = to_string_of_any result2 in
     if s2 = pointer_str then
       Printf.printf "OK: %s -> %s\n" pointer_str frag
···
   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.add p json ~value in
+    let p = Json_pointer.of_string pointer_str in
+    let result = Json_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)
···
 let test_remove json_str pointer_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.of_string_nav pointer_str in
-    let result = Jsont_pointer.remove p json in
+    let p = Json_pointer.of_string_nav pointer_str in
+    let result = Json_pointer.remove p json in
     Printf.printf "%s\n" (json_to_string result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
 let test_replace json_str pointer_str value_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.of_string_nav pointer_str in
+    let p = Json_pointer.of_string_nav pointer_str in
     let value = parse_json value_str in
-    let result = Jsont_pointer.replace p json ~value in
+    let result = Json_pointer.replace 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)
···
 let test_move json_str from_str path_str =
   try
     let json = parse_json json_str in
-    let from = Jsont_pointer.of_string_nav from_str in
-    let path = Jsont_pointer.of_string path_str in
-    let result = Jsont_pointer.move ~from ~path json in
+    let from = Json_pointer.of_string_nav from_str in
+    let path = Json_pointer.of_string path_str in
+    let result = Json_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)
···
 let test_copy json_str from_str path_str =
   try
     let json = parse_json json_str in
-    let from = Jsont_pointer.of_string_nav from_str in
-    let path = Jsont_pointer.of_string path_str in
-    let result = Jsont_pointer.copy ~from ~path json in
+    let from = Json_pointer.of_string_nav from_str in
+    let path = Json_pointer.of_string path_str in
+    let result = Json_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)
···
 let test_test json_str pointer_str expected_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.of_string_nav pointer_str in
+    let p = Json_pointer.of_string_nav pointer_str in
     let expected = parse_json expected_str in
-    let result = Jsont_pointer.test p json ~expected in
+    let result = Json_pointer.test p json ~expected in
     Printf.printf "%b\n" result
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
 let test_has json_str pointer_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.of_string_nav pointer_str in
-    let result = Jsont_pointer.find p json in
+    let p = Json_pointer.of_string_nav pointer_str in
+    let result = Json_pointer.find p json in
     Printf.printf "%b\n" (Option.is_some result)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
···
 (* Test: JMAP extended pointer parse *)
 let test_jmap_parse pointer_str =
   try
-    let p = Jsont_pointer.Jmap.of_string pointer_str in
-    let s = Jsont_pointer.Jmap.to_string p in
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    let s = Json_pointer.Jmap.to_string p in
     if s = "" then Printf.printf "OK: (root)\n"
     else Printf.printf "OK: %s\n" s
   with Jsont.Error e ->
···
 let test_jmap_eval json_str pointer_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.Jmap.of_string pointer_str in
-    let result = Jsont_pointer.Jmap.eval p json in
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    let result = Json_pointer.Jmap.eval p json in
     Printf.printf "OK: %s\n" (json_to_string result)
   with
   | Jsont.Error e ->
···
 let test_jmap_eval_file json_path pointer_str =
   try
     let json = parse_json (read_file json_path) in
-    let p = Jsont_pointer.Jmap.of_string pointer_str in
-    let result = Jsont_pointer.Jmap.eval p json in
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    let result = Json_pointer.Jmap.eval p json in
     Printf.printf "OK: %s\n" (json_to_string result)
   with
   | Jsont.Error e ->
···
 let test_jmap_path_strings json_str pointer_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.Jmap.of_string pointer_str in
-    let codec = Jsont_pointer.Jmap.path_list p Jsont.string in
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    let codec = Json_pointer.Jmap.path_list p Jsont.string in
     let result = match Jsont.Json.decode' codec json with
       | Ok v -> v
       | Error e -> raise (Jsont.Error e)
···
 let test_jmap_path_ints json_str pointer_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.Jmap.of_string pointer_str in
-    let codec = Jsont_pointer.Jmap.path_list p Jsont.int in
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    let codec = Json_pointer.Jmap.path_list p Jsont.int in
     let result = match Jsont.Json.decode' codec json with
       | Ok v -> v
       | Error e -> raise (Jsont.Error e)
···
 let test_jmap_path_single json_str pointer_str =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.Jmap.of_string pointer_str in
-    let codec = Jsont_pointer.Jmap.path p Jsont.string in
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    let codec = Json_pointer.Jmap.path p Jsont.string in
     let result = match Jsont.Json.decode' codec json with
       | Ok v -> v
       | Error e -> raise (Jsont.Error e)
···
 let test_jmap_path_absent json_str pointer_str default =
   try
     let json = parse_json json_str in
-    let p = Jsont_pointer.Jmap.of_string pointer_str in
-    let codec = Jsont_pointer.Jmap.path ~absent:default p Jsont.string in
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    let codec = Json_pointer.Jmap.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)
···
 
 (* 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 idx = Json_pointer.mem name in
+  Format.printf "mem(%s) = %a\n" name Json_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 idx = Json_pointer.nth n in
+  Format.printf "nth(%d) = %a\n" n Json_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)
+      Json_pointer.nth (int_of_string s)
     else
-      Jsont_pointer.mem s
+      Json_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)
+  Printf.printf "%b\n" (Json_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)
+      Json_pointer.nth (int_of_string s)
     else
-      Jsont_pointer.mem s
+      Json_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
+  let cmp = Json_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 r = Json_pointer.root in
+  Printf.printf "root = %s\n" (Json_pointer.to_string r);
+  Printf.printf "is_root(root) = %b\n" (Json_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)
+    let p = Json_pointer.of_string pointer_str in
+    let (Json_pointer.Any ptr) = p in
+    Printf.printf "%b\n" (Json_pointer.is_root ptr)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
 
···
   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 ""
+    if s = "" then Json_pointer.mem ""
     else if String.length s > 0 && s.[0] >= '0' && s.[0] <= '9' then
-      Jsont_pointer.nth (int_of_string s)
+      Json_pointer.nth (int_of_string s)
     else
-      Jsont_pointer.mem s
+      Json_pointer.mem s
   ) parts in
-  let p = Jsont_pointer.make indices in
-  Printf.printf "%s\n" (Jsont_pointer.to_string p)
+  let p = Json_pointer.make indices in
+  Printf.printf "%s\n" (Json_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 base = Json_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)
+        Json_pointer.nth (int_of_string index_str)
       else
-        Jsont_pointer.mem index_str
+        Json_pointer.mem index_str
     in
-    let result = Jsont_pointer.(base / idx) in
-    Printf.printf "%s\n" (Jsont_pointer.to_string result)
+    let result = Json_pointer.(base / idx) in
+    Printf.printf "%s\n" (Json_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)
+    let p = Json_pointer.of_string_nav pointer_str in
+    let append_p = Json_pointer.at_end p in
+    Printf.printf "%s\n" (Json_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)
+    let p1 = Json_pointer.of_string_nav p1_str in
+    let p2 = Json_pointer.of_string_nav p2_str in
+    let result = Json_pointer.concat p1 p2 in
+    Printf.printf "%s\n" (Json_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)
+    let p = Json_pointer.of_string_nav pointer_str in
+    match Json_pointer.parent p with
+    | Some parent -> Printf.printf "Some(%s)\n" (Json_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
+    let p = Json_pointer.of_string_nav pointer_str in
+    match Json_pointer.last p with
+    | Some idx -> Format.printf "Some(%a)\n" Json_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 p = Json_pointer.of_string pointer_str in
     let indices = indices_of_any p in
     let strs = List.map (fun idx ->
       match idx with
···
 (* 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)
+    let p = Json_pointer.of_string pointer_str in
+    match Json_pointer.to_nav p with
+    | Some nav -> Printf.printf "Some(%s)\n" (Json_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)
+    let p = Json_pointer.of_string pointer_str in
+    let nav = Json_pointer.to_nav_exn p in
+    Printf.printf "OK: %s\n" (Json_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)
+    match Json_pointer.of_string_kind pointer_str with
+    | `Nav p -> Printf.printf "Nav(%s)\n" (Json_pointer.to_string p)
+    | `Append p -> Printf.printf "Append(%s)\n" (Json_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
+  match Json_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)
+    let p = Json_pointer.of_uri_fragment_nav frag in
+    Printf.printf "OK: %s\n" (Json_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
+  match Json_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
+    let p = Json_pointer.of_string pointer_str in
+    let (Json_pointer.Any ptr) = p in
+    Format.printf "%a\n" Json_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
+    let p = Json_pointer.of_string pointer_str in
+    let (Json_pointer.Any ptr) = p in
+    Format.printf "%a\n" Json_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)
+    let p1 = Json_pointer.of_string p1_str in
+    let p2 = Json_pointer.of_string p2_str in
+    let (Json_pointer.Any ptr1) = p1 in
+    let (Json_pointer.Any ptr2) = p2 in
+    Printf.printf "%b\n" (Json_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
+    let p1 = Json_pointer.of_string p1_str in
+    let p2 = Json_pointer.of_string p2_str in
+    let (Json_pointer.Any ptr1) = p1 in
+    let (Json_pointer.Any ptr2) = p2 in
+    let cmp = Json_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"
···
     |> 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 p = Json_pointer.of_path path in
+  Printf.printf "%s\n" (Json_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
+    let p = Json_pointer.of_string_nav pointer_str in
+    let path = Json_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 ->
···
 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
+    let p = Json_pointer.of_string_nav pointer_str in
+    match Json_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 ->
···
   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
+    let p = Json_pointer.of_string pointer_str in
+    let result = Json_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)
···
 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
+    let decoded = match Jsont.Json.decode' Json_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
+    let encoded = match Jsont.Json.encode' Json_pointer.jsont decoded with
       | Ok j -> j
       | Error e -> raise (Jsont.Error e)
     in
···
 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
+    let decoded = match Jsont.Json.decode' Json_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)
+    | `Nav p -> Printf.printf "Nav(%s)\n" (Json_pointer.to_string p)
+    | `Append p -> Printf.printf "Append(%s)\n" (Json_pointer.to_string p)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
 
···
 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
+    let decoded = match Jsont.Json.decode' Json_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)
+    Printf.printf "OK: %s\n" (Json_pointer.to_string decoded)
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
 
···
 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
+    let p = Json_pointer.of_string pointer_str in
+    let encoded = match Jsont.Json.encode' Json_pointer.jsont_uri_fragment p with
       | Ok j -> j
       | Error e -> raise (Jsont.Error e)
     in
···
 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 p = Json_pointer.of_string_nav pointer_str in
+    let codec = Json_pointer.path p Jsont.string in
     let result = match Jsont.Json.decode' codec json with
       | Ok v -> v
       | Error e -> raise (Jsont.Error e)
···
 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 p = Json_pointer.of_string_nav pointer_str in
+    let codec = Json_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)
···
 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 p = Json_pointer.of_string pointer_str in
+    let codec = Json_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)
···
 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 p = Json_pointer.of_string_nav pointer_str in
+    let codec = Json_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)
···
 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 p = Json_pointer.of_string_nav pointer_str in
+    let codec = Json_pointer.delete_path p in
     let result = match Jsont.Json.recode' codec json with
       | Ok v -> v
       | Error e -> raise (Jsont.Error e)
···
 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 p = Json_pointer.of_string_nav pointer_str in
+    let codec = Json_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)
···
 
 (* 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)
+  match Json_pointer.Jmap.of_string_result pointer_str with
+  | Ok p -> Printf.printf "Ok(%s)\n" (Json_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
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    Format.printf "%a\n" Json_pointer.Jmap.pp p
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
 
···
 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
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    match Json_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 ->
···
 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
+    let p = Json_pointer.Jmap.of_string pointer_str in
+    match Json_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 ->
···
 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
+    let decoded = match Jsont.Json.decode' Json_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
+    let encoded = match Jsont.Json.encode' Json_pointer.Jmap.jsont decoded with
       | Ok j -> j
       | Error e -> raise (Jsont.Error e)
     in