Update to 1.3

Author: cxa

mksrc.sh

@@ -3,7 +3,7 @@
 echo "Checking out ocaml-container..."
 git submodule update --init
 cd ocaml-containers
-git checkout 1.2
+git checkout 1.3
 echo "Making..."
 make
 echo "Copying sources..."

ocaml-containers

@@ -1,6 +1,6 @@
 {
   "name": "bs-containers-core",
-  "version": "1.2.0-5",
+  "version": "1.3.0+20170817",
   "description": "OCaml-containers core for BuckleScript",
   "main": "index.js",
   "scripts": {
@@ -13,6 +13,6 @@
   },
   "license": "BSD",
   "devDependencies": {
-    "bs-platform": "^1.7.4"
+    "bs-platform": "^1.8.2"
   }
 }

package.json

@@ -212,11 +212,13 @@ let rec find_aux f a i =
     | Some _ as res -> res
     | None -> find_aux f a (i+1)
 
-let find f a =
-  find_aux (fun _ -> f ) a 0
+let find_map f a = find_aux (fun _ -> f ) a 0
 
-let findi f a =
-  find_aux f a 0
+let find = find_map
+
+let find_map_i f a = find_aux f a 0
+
+let findi = find_map_i
 
 let find_idx p a =
   find_aux (fun i x -> if p x then Some (i,x) else None) a 0

src/CCArray.ml

@@ -71,30 +71,44 @@ val sorted : ('a -> 'a -> int) -> 'a t -> 'a array
 
 val sort_indices : ('a -> 'a -> int) -> 'a t -> int array
 (** [sort_indices cmp a] returns a new array [b], with the same length as [a],
-    such that [b.(i)] is the index of the [i]-th element of [a] in [sort cmp a].
-    In other words, [map (fun i -> a.(i)) (sort_indices a) = sorted cmp a].
-    [a] is not modified.
+    such that [b.(i)] is the index at which the [i]-th element of [sorted cmp a] 
+    appears in [a]. [a] is not modified.
+
+    In other words, [map (fun i -> a.(i)) (sort_indices cmp a) = sorted cmp a]. 
+    [sort_indices] yields the inverse permutation of {!sort_ranking}.
+
     @since 1.0 *)
 
 val sort_ranking : ('a -> 'a -> int) -> 'a t -> int array
 (** [sort_ranking cmp a] returns a new array [b], with the same length as [a],
-    such that [b.(i)] is the position in [sorted cmp a] of the [i]-th
-    element of [a].
-    [a] is not modified.
+    such that [b.(i)] is the index at which the [i]-the element of [a] appears
+    in [sorted cmp a]. [a] is not modified.
 
-    In other words, [map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a].
+    In other words, [map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a]. 
+    [sort_ranking] yields the inverse permutation of {!sort_indices}.
 
-    Without duplicates, we also have
+    In the absence of duplicate elements in [a], we also have
     [lookup_exn a.(i) (sorted a) = (sorted_ranking a).(i)]
     @since 1.0 *)
 
+val find_map : ('a -> 'b option) -> 'a t -> 'b option
+(** [find_map f a] returns [Some y] if there is an element [x] such
+    that [f x = Some y], else it returns [None]
+    @since 1.3
+*)
+
 val find : ('a -> 'b option) -> 'a t -> 'b option
-(** [find f a] returns [Some y] if there is an element [x] such
-    that [f x = Some y], else it returns [None] *)
+(** Alias to {!find_map}
+    @deprecated since 1.3 *)
+
+val find_map_i : (int -> 'a -> 'b option) -> 'a t -> 'b option
+(** Like {!find_map}, but also pass the index to the predicate function.
+    @since 1.3 *)
 
 val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option
-(** Like {!find}, but also pass the index to the predicate function.
-    @since 0.3.4 *)
+(** Alias to {!find_map_i}
+    @since 0.3.4
+    @deprecated since 1.3 *)
 
 val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option
 (** [find_idx p x] returns [Some (i,x)] where [x] is the [i]-th element of [l],
@@ -107,7 +121,7 @@ val lookup : ?cmp:'a ord -> 'a -> 'a t -> int option
       [Some i] ([i] the index of the key) otherwise *)
 
 val lookup_exn : ?cmp:'a ord -> 'a -> 'a t -> int
-(** Same as {!lookup_exn}, but
+(** Same as {!lookup}, but
     @raise Not_found if the key is not present *)
 
 val bsearch : ?cmp:('a -> 'a -> int) -> 'a -> 'a t ->

src/CCArray.mli

@@ -86,20 +86,23 @@ val sorted : ('a -> 'a -> int) -> 'a t -> 'a array
 
 val sort_indices : ('a -> 'a -> int) -> 'a t -> int array
 (** [sort_indices cmp a] returns a new array [b], with the same length as [a],
-    such that [b.(i)] is the index of the [i]-th element of [a] in [sort cmp a].
-    In other words, [map (fun i -> a.(i)) (sort_indices a) = sorted cmp a].
-    [a] is not modified.
+    such that [b.(i)] is the index at which the [i]-th element of [sorted cmp a] 
+    appears in [a]. [a] is not modified.
+
+    In other words, [map (fun i -> a.(i)) (sort_indices cmp a) = sorted cmp a]. 
+    [sort_indices] yields the inverse permutation of {!sort_ranking}.
+
     @since 1.0 *)
 
 val sort_ranking : ('a -> 'a -> int) -> 'a t -> int array
 (** [sort_ranking cmp a] returns a new array [b], with the same length as [a],
-    such that [b.(i)] is the position in [sorted cmp a] of the [i]-th
-    element of [a].
-    [a] is not modified.
+    such that [b.(i)] is the index at which the [i]-the element of [a] appears
+    in [sorted cmp a]. [a] is not modified.
 
-    In other words, [map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a].
+    In other words, [map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a]. 
+    [sort_ranking] yields the inverse permutation of {!sort_indices}.
 
-    Without duplicates, we also have
+    In the absence of duplicate elements in [a], we also have
     [lookup_exn a.(i) (sorted a) = (sorted_ranking a).(i)]
     @since 1.0 *)
 
@@ -122,7 +125,7 @@ val lookup : ?cmp:'a ord -> 'a -> 'a t -> int option
       [Some i] ([i] the index of the key) otherwise *)
 
 val lookup_exn : ?cmp:'a ord -> 'a -> 'a t -> int
-(** Same as {!lookup_exn}, but
+(** Same as {!lookup}, but
     @raise Not_found if the key is not present *)
 
 val bsearch : ?cmp:('a -> 'a -> int) -> 'a -> 'a t ->

src/CCArray_slice.mli

@@ -7,7 +7,7 @@ let equal (a:bool) b = a=b
 
 let compare (a:bool) b = Pervasives.compare a b
 
-let negate x = not x
+let negate = not
 
 type 'a printer = Format.formatter -> 'a -> unit
 

src/CCBool.ml

@@ -11,7 +11,8 @@ val compare : t -> t -> int
 val equal : t -> t -> bool
 
 val negate : t -> t
-(** Negation on booleans (functional version of [not]) *)
+(** Negation on booleans (functional version of [not])
+    @deprecate since 1.3, simply use {!not} instead *)
 
 type 'a printer = Format.formatter -> 'a -> unit
 

src/CCBool.mli

@@ -77,7 +77,7 @@ let text out (s:string): unit =
 (*$= & ~printer:(fun s->CCFormat.sprintf "%S" s)
   "a\nb\nc" (sprintf_no_color "@[<v>%a@]%!" text "a b c")
   "a b\nc" (sprintf_no_color "@[<h>%a@]%!" text "a b\nc")
-  *)
+*)
 
 let list ?(sep=return ",@ ") pp fmt l =
   let rec pp_list l = match l with

src/CCFormat.ml

@@ -311,5 +311,5 @@ module Dump : sig
   val result : 'a t -> ('a, string) Result.result t
   val result' : 'a t -> 'e t -> ('a, 'e) Result.result t
   val to_string : 'a t -> 'a -> string
-  (** Alias to {!to_string} *)
+  (** Alias to {!CCFormat.to_string} *)
 end

src/CCFormat.mli

@@ -366,7 +366,7 @@ let combine l1 l2 =
     if List.length l1=List.length l2 \
     then CCList.combine l1 l2 = List.combine l1 l2 \
     else Q.assume_fail() )
-  *)
+*)
 
 let combine_gen l1 l2 =
   let l1 = ref l1 in
@@ -385,7 +385,38 @@ let combine_gen l1 l2 =
     let res1 = combine (take n l1) (take n l2) in \
     let res2 = combine_gen l1 l2 |> of_gen in \
     res1 = res2)
-  *)
+*)
+
+let split l = 
+  let rec direct i l = match l with 
+    | [] -> [], []
+    | [x1, y1] -> [x1], [y1]
+    | [x1, y1; x2, y2] -> [x1;x2], [y1;y2]
+    | [x1, y1; x2, y2; x3, y3] -> [x1;x2;x3], [y1;y2;y3]
+    | [x1, y1; x2, y2; x3, y3; x4, y4] -> [x1;x2;x3;x4], [y1;y2;y3;y4]
+    | _ when i=0 -> split_slow [] [] l
+    | (x1, y1) :: (x2, y2) :: (x3, y3) :: (x4, y4) :: (x5, y5) :: l' ->
+      let rx, ry = direct (i-1) l' in 
+      x1 :: x2 :: x3 :: x4 :: x5 :: rx,
+      y1 :: y2 :: y3 :: y4 :: y5 :: ry
+  and split_slow acc1 acc2 l = match l with
+    | [] -> List.rev acc1, List.rev acc2
+    | (x1, x2) :: tail ->
+      let acc1 = x1 :: acc1
+      and acc2 = x2 :: acc2 in 
+      split_slow acc1 acc2 tail
+  in 
+  direct direct_depth_default_ l
+
+(*$Q 
+  (Q.(list_of_size Gen.(0--10_000) (pair small_int small_string))) (fun l -> \
+    let (l1, l2) = split l in \
+    List.length l1 = List.length l \
+    && List.length l2 = List.length l)
+
+  Q.(list_of_size Gen.(0--10_000) (pair small_int small_int)) (fun l -> \
+    split l = List.split l)
+*)
 
 let return x = [x]
 
@@ -688,18 +719,18 @@ let take_while p l =
 *)
 
 (*$Q
-  Q.(pair (fun1 small_int bool) (list small_int)) (fun (f,l) -> \
-    let l1 = take_while f l in \
-    List.for_all f l1)
+  Q.(pair (fun1 Observable.int bool) (list small_int)) (fun (f,l) -> \
+    let l1 = take_while (Q.Fn.apply f) l in \
+    List.for_all (Q.Fn.apply f) l1)
 *)
 
 let rec drop_while p l = match l with
   | [] -> []
   | x :: l' -> if p x then drop_while p l' else l
 
 (*$Q
-  Q.(pair (fun1 small_int bool) (list small_int)) (fun (f,l) -> \
-    take_while f l @ drop_while f l = l)
+  Q.(pair (fun1 Observable.int bool) (list small_int)) (fun (f,l) -> \
+    take_while (Q.Fn.apply f) l @ drop_while (Q.Fn.apply f) l = l)
 *)
 
 let take_drop_while p l =
@@ -720,9 +751,9 @@ let take_drop_while p l =
   direct direct_depth_default_ p l
 
 (*$Q
-  Q.(pair (fun1 small_int bool) (list small_int)) (fun (f,l) -> \
-    let l1,l2 = take_drop_while f l in \
-    (l1 = take_while f l) && (l2 = drop_while f l))
+  Q.(pair (fun1 Observable.int bool) (list small_int)) (fun (f,l) -> \
+    let l1,l2 = take_drop_while (Q.Fn.apply f) l in \
+    (l1 = take_while (Q.Fn.apply f) l) && (l2 = drop_while (Q.Fn.apply f) l))
 *)
 
 let last n l =
@@ -811,6 +842,48 @@ let filter_map f l =
       [ 1; 2; 3; 4; 5; 6 ])
 *)
 
+let keep_some l = filter_map (fun x->x) l
+
+let keep_ok l =
+  filter_map
+    (function
+      | Result.Ok x -> Some x
+      | Result.Error _ -> None)
+    l
+
+let all_some l =
+  try Some (map (function Some x -> x | None -> raise Exit) l)
+  with Exit -> None
+
+(*$=
+  (Some []) (all_some [])
+  (Some [1;2;3]) (all_some [Some 1; Some 2; Some 3])
+  None (all_some [Some 1; None; None; Some 4])
+*)
+
+let all_ok l =
+  let err = ref None in
+  try
+    Result.Ok
+      (map
+         (function Result.Ok x -> x | Error e -> err := Some e; raise Exit)
+         l)
+  with Exit ->
+    begin match !err with
+      | None -> assert false
+      | Some e -> Result.Error e
+    end
+
+(*$inject
+  open Result
+*)
+
+(*$=
+  (Ok []) (all_ok [])
+  (Ok [1;2;3]) (all_ok [Ok 1; Ok 2; Ok 3])
+  (Error "e2") (all_ok [Ok 1; Error "e2"; Error "e3"; Ok 4])
+*)
+
 let mem ?(eq=(=)) x l =
   let rec search eq x l = match l with
     | [] -> false

src/CCList.ml

@@ -92,6 +92,9 @@ val combine_gen : 'a list -> 'b list -> ('a * 'b) gen
     instead, the output has as many pairs as the smallest input list.
     @since 1.2 *)
 
+val split : ('a * 'b) t -> 'a t * 'b t 
+(** A tail-recursive version of {!List.split}. *)
+
 val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
 
 val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
@@ -111,13 +114,13 @@ val fold_product : ('c -> 'a -> 'b -> 'c) -> 'c -> 'a t -> 'b t -> 'c
 val cartesian_product : 'a t t -> 'a t t
 (**
     For example:
-    {[
-      # cartesian_product [[1;2];[3];[4;5;6]] =
-          [[1;3;4];[1;3;5];[1;3;6];[2;3;4];[2;3;5];[2;3;6]];;
-      # cartesian_product [[1;2];[];[4;5;6]] = [];;
-      # cartesian_product [[1;2];[3];[4];[5];[6]] =
-          [[1;3;4;5;6];[2;3;4;5;6]];;
-    ]}
+   {[
+     # cartesian_product [[1;2];[3];[4;5;6]] =
+     [[1;3;4];[1;3;5];[1;3;6];[2;3;4];[2;3;5];[2;3;6]];;
+     # cartesian_product [[1;2];[];[4;5;6]] = [];;
+     # cartesian_product [[1;2];[3];[4];[5];[6]] =
+     [[1;3;4;5;6];[2;3;4;5;6]];;
+   ]}
     invariant: [cartesian_product l = map_product id l].
     @since 1.2 *)
 
@@ -247,6 +250,26 @@ val remove : ?eq:('a -> 'a -> bool) -> x:'a -> 'a t -> 'a t
 val filter_map : ('a -> 'b option) -> 'a t -> 'b t
 (** Map and remove elements at the same time *)
 
+val keep_some : 'a option t -> 'a t
+(** [filter_some l] retains only elements of the form [Some x].
+    Same as [filter_map CCFun.id]
+    @since 1.3 *)
+
+val keep_ok : ('a, _) Result.result t -> 'a t
+(** [filter_some l] retains only elements of the form [Some x].
+    Same as [filter_map CCFun.id]
+    @since 1.3 *)
+
+val all_some : 'a option t -> 'a t option
+(** [all_some l] returns [Some l'] if all elements of [l] are of the form [Some x],
+    or [None] otherwise.
+    @since 1.3 *)
+
+val all_ok : ('a, 'err) Result.result t -> ('a t, 'err) Result.result
+(** [all_ok l] returns [Ok l'] if all elements of [l] are of the form [Ok x],
+    or [Error e] otherwise (with the first error met).
+    @since 1.3 *)
+
 val sorted_merge : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
 (** Merges elements from both sorted list *)
 
@@ -498,3 +521,5 @@ end
 
 val pp : ?start:string -> ?stop:string -> ?sep:string ->
   'a printer -> 'a t printer
+
+(** {2 Lists of pairs} *)

src/CCList.mli

@@ -129,7 +129,7 @@ let fold_ok f acc r = match r with
 (*$=
   42 (fold_ok (+) 2 (Ok 40))
   40 (fold_ok (+) 40 (Error "foo"))
-  *)
+*)
 
 let is_ok = function
   | Ok _ -> true