pp

doc/dune

···
 (mdx
- (libraries jsont jsont.bytesrw jsont_pointer))
+ (libraries jsont jsont.bytesrw jsont_pointer jsont_pointer_top))

doc/tutorial.md

···
 
 ```ocaml
 # open Jsont_pointer;;
+# #install_printer Jsont_pointer_top.printer;;
 # let parse_json s =
     match Jsont_bytesrw.decode_string Jsont.json s with
     | Ok json -> json
···
     | Ok s -> s
     | Error e -> failwith e;;
 val json_to_string : Jsont.json -> string = <fun>
-# let show_pointer p =
-    let idxs = indices p in
-    let show_index = function
-      | `Mem s -> "Mem:" ^ s
-      | `Nth n -> "Nth:" ^ string_of_int n
-      | `End -> "End"
-    in
-    "[" ^ String.concat ", " (List.map show_index idxs) ^ "]";;
-val show_pointer : t -> string = <fun>
 ```
 
 ## What is JSON Pointer?
···
 
 ```ocaml
 # let ptr = of_string "/users/0/name";;
-val ptr : t = <abstr>
+val ptr : t = [`Mem "users"; `Nth 0; `Mem "name"]
 # get ptr users_json;;
 - : Jsont.json = Jsont.String ("Alice", <abstr>)
 ```
···
 Let's see this in action:
 
 ```ocaml
-# let empty_ptr = of_string "";;
-val empty_ptr : t = <abstr>
-# show_pointer empty_ptr;;
-- : string = "[]"
+# of_string "";;
+- : t = []
 ```
 
 The empty pointer has no reference tokens - it points to the root.
 
 ```ocaml
-# let foo_ptr = of_string "/foo";;
-val foo_ptr : t = <abstr>
-# show_pointer foo_ptr;;
-- : string = "[Mem:foo]"
+# of_string "/foo";;
+- : t = [`Mem "foo"]
 ```
 
 The pointer `/foo` has one token: `foo`. Since it's not a number, it's
 interpreted as an object member name (`Mem`).
 
 ```ocaml
-# let foo_0_ptr = of_string "/foo/0";;
-val foo_0_ptr : t = <abstr>
-# show_pointer foo_0_ptr;;
-- : string = "[Mem:foo, Nth:0]"
+# of_string "/foo/0";;
+- : t = [`Mem "foo"; `Nth 0]
 ```
 
 Here we have two tokens: `foo` (a member name) and `0` (interpreted as
 an array index `Nth`).
 
 ```ocaml
-# show_pointer (of_string "/foo/bar/baz");;
-- : string = "[Mem:foo, Mem:bar, Mem:baz]"
+# of_string "/foo/bar/baz";;
+- : t = [`Mem "foo"; `Mem "bar"; `Mem "baz"]
 ```
 
 Multiple tokens navigate deeper into nested structures.
···
 - : (t, string) result =
 Error "Invalid JSON Pointer: must be empty or start with '/': foo"
 # of_string_result "/valid";;
-- : (t, string) result = Ok <abstr>
+- : (t, string) result = Ok [`Mem "valid"]
 ```
 
 ## Evaluation: Navigating JSON
···
 
 ```ocaml
 # let slash_ptr = make [`Mem "a/b"];;
-val slash_ptr : t = <abstr>
+val slash_ptr : t = [`Mem "a/b"]
 # to_string slash_ptr;;
 - : string = "/a~1b"
 # get slash_ptr rfc_example |> json_to_string;;
···
 > note that leading zeros are not allowed
 
 ```ocaml
-# show_pointer (of_string "/foo/0");;
-- : string = "[Mem:foo, Nth:0]"
+# of_string "/foo/0";;
+- : t = [`Mem "foo"; `Nth 0]
 ```
 
 Zero itself is fine.
 
 ```ocaml
-# show_pointer (of_string "/foo/01");;
-- : string = "[Mem:foo, Mem:01]"
+# of_string "/foo/01";;
+- : t = [`Mem "foo"; `Mem "01"]
 ```
 
 But `01` has a leading zero, so it's NOT treated as an array index - it
···
 how it parses:
 
 ```ocaml
-# show_pointer (of_string "/foo/-");;
-- : string = "[Mem:foo, End]"
+# of_string "/foo/-";;
+- : t = [`Mem "foo"; `End]
 ```
 
 The `-` is recognized as a special `End` index.
···
 
 ```ocaml
 # let p = make [`Mem "a/b"];;
-val p : t = <abstr>
+val p : t = [`Mem "a/b"]
 # to_string p;;
 - : string = "/a~1b"
-# let p' = of_string "/a~1b";;
-val p' : t = <abstr>
-# show_pointer p';;
-- : string = "[Mem:a/b]"
+# of_string "/a~1b";;
+- : t = [`Mem "a/b"]
 ```
 
 ### Escaping in Action
···
 
 ```ocaml
 # let port_ptr = make [`Mem "database"; `Mem "port"];;
-val port_ptr : t = <abstr>
+val port_ptr : 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 : t = <abstr>
+val first_feature_ptr : t = [`Mem "features"; `Nth 0]
 # to_string first_feature_ptr;;
 - : string = "/features/0"
 ```
···
 
 ```ocaml
 # let db_ptr = of_string "/database";;
-val db_ptr : t = <abstr>
+val db_ptr : t = [`Mem "database"]
 # let creds_ptr = append db_ptr (`Mem "credentials");;
-val creds_ptr : t = <abstr>
+val creds_ptr : t = [`Mem "database"; `Mem "credentials"]
 # let user_ptr = append creds_ptr (`Mem "username");;
-val user_ptr : t = <abstr>
+val user_ptr : t = [`Mem "database"; `Mem "credentials"; `Mem "username"]
 # to_string user_ptr;;
 - : string = "/database/credentials/username"
 ```
···
 
 ```ocaml
 # let base = of_string "/api/v1";;
-val base : t = <abstr>
+val base : t = [`Mem "api"; `Mem "v1"]
 # let endpoint = of_string "/users/0";;
-val endpoint : t = <abstr>
+val endpoint : t = [`Mem "users"; `Nth 0]
 # to_string (concat base endpoint);;
 - : string = "/api/v1/users/0"
 ```

src/jsont_pointer.ml

···
 let pp ppf p =
   Format.pp_print_string ppf (to_string p)
 
+let pp_verbose ppf p =
+  let pp_index ppf = function
+    | `Mem s -> Format.fprintf ppf "`Mem %S" s
+    | `Nth n -> Format.fprintf ppf "`Nth %d" n
+    | `End -> Format.fprintf ppf "`End"
+  in
+  Format.fprintf ppf "[%a]"
+    (Format.pp_print_list ~pp_sep:(fun ppf () -> Format.fprintf ppf "; ") pp_index)
+    (indices p)
+
 (* Comparison *)
 
 let segment_equal s1 s2 = match s1, s2 with

src/jsont_pointer.mli

···
 val pp : Format.formatter -> t -> unit
 (** [pp] formats a pointer using {!to_string}. *)
 
+val pp_verbose : Format.formatter -> t -> unit
+(** [pp_verbose] formats a pointer showing its index structure.
+    For example, [/foo/0/-] is formatted as [[`Mem "foo"; `Nth 0; `End]].
+    Useful for debugging and understanding pointer structure. *)
+
 (** {2:comparison Comparison} *)
 
 val equal : t -> t -> bool