Merge pull request #77 from benbellick/add-tuple-helpers

Add tuple helpers

Author: mattjbray

src-otoml/dune

@@ -1,4 +1,3 @@
-
 (library
  (name decoders_otoml)
  (public_name decoders-otoml)

src/decode.ml

@@ -329,6 +329,38 @@ module Make (Decodeable : Decodeable) :
         (fail "Expected a list").dec value
 
 
+  let ( >>=:: ) fst rest = uncons rest fst
+
+  let empty_list =
+    Decoder.of_decode_fun
+    @@ fun value ->
+    match Decodeable.get_list value with
+    | Some [] ->
+        Ok ()
+    | Some _ ->
+        (fail "Expected an empty list").dec value
+    | None ->
+        (fail "Expected a list").dec value
+
+
+  let tuple2 d0 d1 =
+    d0 >>=:: fun arg0 -> d1 >>=:: fun arg1 -> succeed (arg0, arg1)
+
+
+  let tuple3 d0 d1 d2 =
+    d0
+    >>=:: fun arg0 ->
+    d1 >>=:: fun arg1 -> d2 >>=:: fun arg2 -> succeed (arg0, arg1, arg2)
+
+
+  let tuple4 d0 d1 d2 d3 =
+    d0
+    >>=:: fun arg0 ->
+    d1
+    >>=:: fun arg1 ->
+    d2 >>=:: fun arg2 -> d3 >>=:: fun arg3 -> succeed (arg0, arg1, arg2, arg3)
+
+
   let rec at : string list -> 'a decoder -> 'a decoder =
    fun path decoder ->
     match path with

src/sig.ml

@@ -117,7 +117,36 @@ module type S = sig
 
       (If you squint, the uncons operator [>>=::] kind of looks like the cons
       operator [::].)
-  *)
+   *)
+
+  val empty_list : unit decoder
+
+  val tuple2 : 'a decoder -> 'b decoder -> ('a * 'b) decoder
+  (** Decode a collection into an OCaml 2-tuple.
+
+      For example, to decode this json:
+
+      {[
+          [true, "string"]
+      ]}
+
+      we can use this decoder:
+
+      {[
+         tuple2 bool string
+      ]}
+     *)
+
+  val tuple3 : 'a decoder -> 'b decoder -> 'c decoder -> ('a * 'b * 'c) decoder
+  (** Decode a collection into an OCaml 3-tuple. *)
+
+  val tuple4 :
+       'a decoder
+    -> 'b decoder
+    -> 'c decoder
+    -> 'd decoder
+    -> ('a * 'b * 'c * 'd) decoder
+  (** Decode a collection into an OCaml 4-tuple. *)
 
   (** {1 Object primitives} *)
 

test-yojson/main.ml

@@ -172,13 +172,58 @@ let yojson_basic_suite =
             Format.asprintf "@,@[%a@]" pp_error e )
   in
 
+  let tupleN_test =
+    "TupleN"
+    >:: fun _ ->
+    let module M = struct
+      type t2 = int * string
+
+      let t2_to_string ((i, s) : t2) = Printf.sprintf "(%i, %s)" i s
+    end in
+    let open M in
+    decoder_test
+      ()
+      ~decoder:(tuple2 int string)
+      ~input:{|[149, "my string"]|}
+      ~expected:(149, "my string")
+      ~printer:t2_to_string
+  in
+  let empty_list_test =
+    "empty_list"
+    >:: fun _ ->
+    decoder_test
+      ()
+      ~decoder:empty_list
+      ~input:{|[]|}
+      ~expected:()
+      ~printer:(fun () -> Printf.sprintf "()")
+  in
+  let empty_list_nonempty_test =
+    "empty_list_enforced"
+    >:: fun _ ->
+    let input = {|[1, 2]|} in
+    let expected_error =
+      let open Decoders in
+      Error.make ~context:(`List [ `Int 1; `Int 2 ]) "Expected an empty list"
+    in
+    match decode_string empty_list input with
+    | Ok _ ->
+        assert_string "Expected an error"
+    | Error error ->
+        assert_equal expected_error error ~printer:(fun e ->
+            Format.asprintf "@,@[%a@]" pp_error e )
+  in
+
   "Yojson.Basic"
   >::: [ list_string_test
        ; array_string_test
        ; fix_one_of_test
        ; mut_rec_test
        ; string_or_floatlit_test
        ; grouping_errors_test
+       ; tupleN_test
+       ; empty_list_test
+       ; empty_list_nonempty_test
        ]