From a8babbd9413fdfc0e83b3e97836cb1fe0a8a5423 Mon Sep 17 00:00:00 2001
From: Simon Cruanes <simon.cruanes.2007@m4x.org>
Date: Fri, 11 Nov 2016 00:52:44 +0100
Subject: [PATCH] add labels to CCList

---
 src/core/CCList.ml     | 173 +++++++++++++++++++++--------------------
 src/core/CCList.mli    |  61 ++++++++-------
 src/data/CCHashTrie.ml |   4 +-
 src/data/CCWBTree.ml   |   2 +-
 4 files changed, 121 insertions(+), 119 deletions(-)

diff --git a/src/core/CCList.ml b/src/core/CCList.ml
index 65b55f72..163ab17f 100644
--- a/src/core/CCList.ml
+++ b/src/core/CCList.ml
@@ -18,7 +18,7 @@ let is_empty = function
 (* max depth for direct recursion *)
 let direct_depth_default_ = 1000
 
-let map f l =
+let map ~f l =
   let rec direct f i l = match l with
     | [] -> []
     | [x] -> [f x]
@@ -40,7 +40,7 @@ let map f l =
     List.rev (List.rev_map f l) = map f l)
 *)
 
-let (>|=) l f = map f l
+let (>|=) l f = map ~f:f l
 
 let direct_depth_append_ = 10_000
 
@@ -78,7 +78,7 @@ let cons_maybe o l = match o with
 
 let direct_depth_filter_ = 10_000
 
-let filter p l =
+let filter ~f l =
   let rec direct i p l = match l with
     | [] -> []
     | _ when i=0 -> safe p l []
@@ -89,7 +89,7 @@ let filter p l =
     | x::l' when not (p x) -> safe p l' acc
     | x::l' -> safe p l' (x::acc)
   in
-  direct direct_depth_filter_ p l
+  direct direct_depth_filter_ f l
 
 (*$= & ~printer:CCInt.to_string
   500 (filter (fun x->x mod 2 = 0) (1 -- 1000) |> List.length)
@@ -122,37 +122,38 @@ let fold_right f l acc =
     l = fold_right (fun x y->x::y) l [])
 *)
 
-let rec fold_while f acc = function
+let rec fold_while ~f ~init:acc = function
   | [] -> acc
   | e::l -> let acc, cont = f acc e in
     match cont with
     | `Stop -> acc
-    | `Continue -> fold_while f acc l
+    | `Continue -> fold_while ~f ~init:acc l
 
 (*$T
-  fold_while (fun acc b -> if b then acc+1, `Continue else acc, `Stop) 0 [true;true;false;true] = 2
+  fold_while ~f:(fun acc b -> if b then acc+1, `Continue else acc, `Stop) \
+    ~init:0 [true;true;false;true] = 2
 *)
 
-let fold_map f acc l =
+let fold_map ~f ~init l =
   let rec aux f acc map_acc l = match l with
     | [] -> acc, List.rev map_acc
     | x :: l' ->
         let acc, y = f acc x in
         aux f acc (y :: map_acc) l'
   in
-  aux f acc [] l
+  aux f init [] l
 
 (*$=
   (6, ["1"; "2"; "3"]) \
-    (fold_map (fun acc x->acc+x, string_of_int x) 0 [1;2;3])
+    (fold_map ~f:(fun acc x->acc+x, string_of_int x) ~init:0 [1;2;3])
 *)
 
 (*$Q
   Q.(list int) (fun l -> \
-    fold_map (fun acc x -> x::acc, x) [] l = (List.rev l, l))
+    fold_map ~f:(fun acc x -> x::acc, x) ~init:[] l = (List.rev l, l))
 *)
 
-let fold_map2 f acc l1 l2 =
+let fold_map2 ~f ~init l1 l2 =
   let rec aux f acc map_acc l1 l2 = match l1, l2 with
     | [], [] -> acc, List.rev map_acc
     | [], _
@@ -161,56 +162,56 @@ let fold_map2 f acc l1 l2 =
         let acc, y = f acc x1 x2 in
         aux f acc (y :: map_acc) l1' l2'
   in
-  aux f acc [] l1 l2
+  aux f init [] l1 l2
 
 (*$=
   (310, ["1 10"; "2 0"; "3 100"]) \
-    (fold_map2 (fun acc x y->acc+x*y, string_of_int x ^ " " ^ string_of_int y) \
-    0 [1;2;3] [10;0;100])
+    (fold_map2 ~f:(fun acc x y->acc+x*y, string_of_int x ^ " " ^ string_of_int y) \
+      ~init:0 [1;2;3] [10;0;100])
 *)
 
 (*$T
-  (try ignore (fold_map2 (fun _ _ _ -> assert false) 42 [] [1]); false \
+  (try ignore (fold_map2 ~f:(fun _ _ _ -> assert false) ~init:42 [] [1]); false \
    with Invalid_argument _ -> true)
 *)
 
-let fold_filter_map f acc l =
+let fold_filter_map ~f ~init l =
   let rec aux f acc map_acc l = match l with
     | [] -> acc, List.rev map_acc
     | x :: l' ->
         let acc, y = f acc x in
         aux f acc (cons_maybe y map_acc) l'
   in
-  aux f acc [] l
+  aux f init [] l
 
 (*$= & ~printer:Q.Print.(pair int (list int))
   (List.fold_left (+) 0 (1--10), [2;4;6;8;10]) \
-  (fold_filter_map (fun acc x -> acc+x, if x mod 2 = 0 then Some x else None) \
-    0 (1--10))
+  (fold_filter_map ~f:(fun acc x -> acc+x, if x mod 2 = 0 then Some x else None) \
+    ~init:0 (1--10))
 *)
 
-let fold_flat_map f acc l =
+let fold_flat_map ~f ~init l =
   let rec aux f acc map_acc l = match l with
     | [] -> acc, List.rev map_acc
     | x :: l' ->
         let acc, y = f acc x in
         aux f acc (List.rev_append y map_acc) l'
   in
-  aux f acc [] l
+  aux f init [] l
 
 (*$=
   (6, ["1"; "a1"; "2"; "a2"; "3"; "a3"]) \
     (let pf = Printf.sprintf in \
-      fold_flat_map (fun acc x->acc+x, [pf "%d" x; pf "a%d" x]) 0 [1;2;3])
+      fold_flat_map ~f:(fun acc x->acc+x, [pf "%d" x; pf "a%d" x]) ~init:0 [1;2;3])
 *)
 
 (*$Q
   Q.(list int) (fun l -> \
-    fold_flat_map (fun acc x -> x::acc, [x;x+10]) [] l = \
-      (List.rev l, flat_map (fun x->[x;x+10]) l) )
+    fold_flat_map ~f:(fun acc x -> x::acc, [x;x+10]) ~init:[] l = \
+      (List.rev l, flat_map ~f:(fun x->[x;x+10]) l) )
 *)
 
-let init len f =
+let init len ~f =
   let rec init_rec acc i f =
     if i=0 then f i :: acc
     else init_rec (f i :: acc) (i-1) f
@@ -220,9 +221,9 @@ let init len f =
   else init_rec [] (len-1) f
 
 (*$T
-  init 0 (fun _ -> 0) = []
-  init 1 (fun x->x) = [0]
-  init 1000 (fun x->x) = 0--999
+  init 0 ~f:(fun _ -> 0) = []
+  init 1 ~f:(fun x->x) = [0]
+  init 1000 ~f:(fun x->x) = 0--999
 *)
 
 let rec compare f l1 l2 = match l1, l2 with
@@ -242,7 +243,7 @@ let rec equal f l1 l2 = match l1, l2 with
   equal CCInt.equal (1--1_000_000) (1--1_000_000)
 *)
 
-let flat_map f l =
+let flat_map ~f l =
   let rec aux f l kont = match l with
     | [] -> kont []
     | x::l' ->
@@ -266,19 +267,19 @@ let flatten l = fold_right append l []
 
 (*$T
   flatten [[1]; [2;3;4]; []; []; [5;6]] = 1--6
-  flatten (init 300_001 (fun x->[x])) = 0--300_000
+  flatten (init 300_001 ~f:(fun x->[x])) = 0--300_000
 *)
 
-let product f l1 l2 =
-  flat_map (fun x -> map (fun y -> f x y) l2) l1
+let product ~f l1 l2 =
+  flat_map ~f:(fun x -> map ~f:(fun y -> f x y) l2) l1
 
-let fold_product f acc l1 l2 =
+let fold_product ~f ~init l1 l2 =
   List.fold_left
     (fun acc x1 ->
       List.fold_left
         (fun acc x2 -> f acc x1 x2)
-        acc l2
-    ) acc l1
+        acc l2)
+    init l1
 
 let diagonal l =
   let rec gen acc l = match l with
@@ -296,7 +297,7 @@ let diagonal l =
   diagonal [1;2;3] |> List.sort Pervasives.compare = [1, 2; 1, 3; 2, 3]
 *)
 
-let partition_map f l =
+let partition_map ~f l =
   let rec iter f l1 l2 l = match l with
   | [] -> List.rev l1, List.rev l2
   | x :: tl ->
@@ -309,11 +310,11 @@ let partition_map f l =
 
 (*$R
   let l1, l2 =
-    partition_map (function
+    partition_map ~f:(function
       | n when n = 0 -> `Drop
       | n when n mod 2 = 0 -> `Left n
-      | n -> `Right n
-    ) [0;1;2;3;4]
+      | n -> `Right n)
+    [0;1;2;3;4]
   in
   assert_equal [2;4] l1;
   assert_equal [1;3] l2
@@ -321,13 +322,13 @@ let partition_map f l =
 
 let return x = [x]
 
-let (>>=) l f = flat_map f l
+let (>>=) l f = flat_map ~f l
 
-let (<$>) = map
+let (<$>) f x = map ~f x
 
 let pure = return
 
-let (<*>) funs l = product (fun f x -> f x) funs l
+let (<*>) funs l = product ~f:(fun f x -> f x) funs l
 
 let sorted_merge ?(cmp=Pervasives.compare) l1 l2 =
   let rec recurse cmp acc l1 l2 = match l1,l2 with
@@ -530,7 +531,7 @@ let split = take_drop
     l1 @ l2 = l )
 *)
 
-let take_while p l =
+let take_while ~f l =
   let rec direct i p l = match l with
     | [] -> []
     | _ when i=0 -> safe p [] l
@@ -541,13 +542,13 @@ let take_while p l =
     | x :: l' ->
         if p x then safe p (x::acc) l' else List.rev acc
   in
-  direct direct_depth_default_ p l
+  direct direct_depth_default_ f l
 
 (*$T
-  take_while (fun x->x<10) (1 -- 20) = (1--9)
-  take_while (fun x->x <> 0) [0;1;2;3] = []
-  take_while (fun _ -> true) [] = []
-  take_while (fun _ -> true) (1--10) = (1--10)
+  take_while ~f:(fun x->x<10) (1 -- 20) = (1--9)
+  take_while ~f:(fun x->x <> 0) [0;1;2;3] = []
+  take_while ~f:(fun _ -> true) [] = []
+  take_while ~f:(fun _ -> true) (1--10) = (1--10)
 *)
 
 (*$Q
@@ -556,9 +557,9 @@ let take_while p l =
     List.for_all f l1)
 *)
 
-let rec drop_while p l = match l with
+let rec drop_while ~f l = match l with
   | [] -> []
-  | x :: l' -> if p x then drop_while p l' else l
+  | x :: l' -> if f x then drop_while ~f l' else l
 
 (*$Q
   Q.(pair (fun1 small_int bool) (list small_int)) (fun (f,l) -> \
@@ -587,23 +588,23 @@ let rec last_opt = function
   None (last_opt [])
 *)
 
-let rec find_pred p l = match l with
+let rec find_pred ~f l = match l with
   | [] -> None
-  | x :: _ when p x -> Some x
-  | _ :: tl -> find_pred p tl
+  | x :: _ when f x -> Some x
+  | _ :: tl -> find_pred ~f tl
 
-let find_pred_exn p l = match find_pred p l with
+let find_pred_exn ~f l = match find_pred ~f l with
   | None -> raise Not_found
   | Some x -> x
 
 (*$T
-  find_pred ((=) 4) [1;2;5;4;3;0] = Some 4
-  find_pred (fun _ -> true) [] = None
-  find_pred (fun _ -> false) (1 -- 10) = None
-  find_pred (fun x -> x < 10) (1 -- 9) = Some 1
+  find_pred ~f:((=) 4) [1;2;5;4;3;0] = Some 4
+  find_pred ~f:(fun _ -> true) [] = None
+  find_pred ~f:(fun _ -> false) (1 -- 10) = None
+  find_pred ~f:(fun x -> x < 10) (1 -- 9) = Some 1
 *)
 
-let find_mapi f l =
+let find_mapi ~f l =
   let rec aux f i = function
     | [] -> None
     | x::l' ->
@@ -612,32 +613,32 @@ let find_mapi f l =
           | None -> aux f (i+1) l'
   in aux f 0 l
 
-let find_map f l = find_mapi (fun _ -> f) l
+let find_map ~f l = find_mapi ~f:(fun _ -> f) l
 
 let find = find_map
 let findi = find_mapi
 
-let find_idx p l = find_mapi (fun i x -> if p x then Some (i, x) else None) l
+let find_idx ~f l = find_mapi ~f:(fun i x -> if f x then Some (i, x) else None) l
 
 (*$T
   find (fun x -> if x=3 then Some "a" else None) [1;2;3;4] = Some "a"
   find (fun x -> if x=3 then Some "a" else None) [1;2;4;5] = None
 *)
 
-let remove ?(eq=(=)) ~x l =
+let remove ?(eq=(=)) ~key l =
   let rec remove' eq x acc l = match l with
     | [] -> List.rev acc
     | y :: tail when eq x y -> remove' eq x acc tail
     | y :: tail -> remove' eq x (y::acc) tail
   in
-  remove' eq x [] l
+  remove' eq key [] l
 
 (*$T
-  remove ~x:1 [2;1;3;3;2;1] = [2;3;3;2]
-  remove ~x:10 [1;2;3] = [1;2;3]
+  remove ~key:1 [2;1;3;3;2;1] = [2;3;3;2]
+  remove ~key:10 [1;2;3] = [1;2;3]
 *)
 
-let filter_map f l =
+let filter_map ~f l =
   let rec recurse acc l = match l with
   | [] -> List.rev acc
   | x::l' ->
@@ -718,32 +719,32 @@ let inter ?(eq=(=)) l1 l2 =
   inter [1;2;4] [2;3;4;5] = [2;4]
 *)
 
-let mapi f l =
+let mapi ~f l =
   let r = ref 0 in
-  map
-    (fun x ->
+  map l
+    ~f:(fun x ->
        let y = f !r x in
-       incr r; y
-    ) l
+       incr r;
+       y)
 
 (*$T
-  mapi (fun i x -> i*x) [10;10;10] = [0;10;20]
+  mapi ~f:(fun i x -> i*x) [10;10;10] = [0;10;20]
 *)
 
-let iteri f l =
+let iteri ~f l =
   let rec aux f i l = match l with
     | [] -> ()
     | x::l' -> f i x; aux f (i+1) l'
   in aux f 0 l
 
-let foldi f acc l =
+let foldi ~f ~init l =
   let rec foldi f acc i l = match l with
     | [] -> acc
     | x::l' ->
       let acc = f acc i x in
       foldi f acc (i+1) l'
   in
-  foldi f acc 0 l
+  foldi f init 0 l
 
 let rec get_at_idx_exn i l = match l with
   | [] -> raise Not_found
@@ -1018,7 +1019,7 @@ end
 module Traverse(M : MONAD) = struct
   open M
 
-  let map_m f l =
+  let map_m ~f l =
     let rec aux f acc l = match l with
       | [] -> return (List.rev acc)
       | x::tail ->
@@ -1026,23 +1027,23 @@ module Traverse(M : MONAD) = struct
           aux f (x' :: acc) tail
     in aux f [] l
 
-  let rec map_m_par f l = match l with
+  let rec map_m_par ~f l = match l with
     | [] -> M.return []
     | x::tl ->
         let x' = f x in
-        let tl' = map_m_par f tl in
+        let tl' = map_m_par ~f tl in
         x' >>= fun x' ->
         tl' >>= fun tl' ->
         M.return (x'::tl')
 
-  let sequence_m l = map_m (fun x->x) l
+  let sequence_m l = map_m l ~f:(fun x->x)
 
-  let rec fold_m f acc l = match l with
-    | [] -> return acc
+  let rec fold_m ~f ~init l = match l with
+    | [] -> return init
     | x :: l' ->
-        f acc x
+        f init x
         >>= fun acc' ->
-        fold_m f acc' l'
+        fold_m ~f ~init:acc' l'
 end
 
 (** {2 Conversions} *)
@@ -1054,7 +1055,7 @@ type 'a printer = Format.formatter -> 'a -> unit
 type 'a random_gen = Random.State.t -> 'a
 
 let random_len len g st =
-  init len (fun _ -> g st)
+  init len ~f:(fun _ -> g st)
 
 (*$T
   random_len 10 CCInt.random_small (Random.State.make [||]) |> List.length = 10
@@ -1076,7 +1077,7 @@ let random_choose l = match l with
         let i = Random.State.int st len in
         List.nth l i
 
-let random_sequence l st = map (fun g -> g st) l
+let random_sequence l st = map l ~f:(fun g -> g st)
 
 let to_seq l k = List.iter k l
 let of_seq seq =
diff --git a/src/core/CCList.mli b/src/core/CCList.mli
index b6f01ecc..5d8b01c4 100644
--- a/src/core/CCList.mli
+++ b/src/core/CCList.mli
@@ -11,7 +11,7 @@ val is_empty : _ t -> bool
 (** [is_empty l] returns [true] iff [l = []]
     @since 0.11 *)
 
-val map : ('a -> 'b) -> 'a t -> 'b t
+val map : f:('a -> 'b) -> 'a t -> 'b t
 (** Safe version of map *)
 
 val (>|=) : 'a t -> ('a -> 'b) -> 'b t
@@ -32,38 +32,38 @@ val cons_maybe : 'a option -> 'a t -> 'a t
 
 val (@) : 'a t -> 'a t -> 'a t
 
-val filter : ('a -> bool) -> 'a t -> 'a t
+val filter : f:('a -> bool) -> 'a t -> 'a t
 (** Safe version of {!List.filter} *)
 
 val fold_right : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b
 (** Safe version of [fold_right] *)
 
-val fold_while : ('a -> 'b -> 'a * [`Stop | `Continue]) -> 'a -> 'b t -> 'a
+val fold_while : f:('a -> 'b -> 'a * [`Stop | `Continue]) -> init:'a -> 'b t -> 'a
 (** Fold until a stop condition via [('a, `Stop)] is
     indicated by the accumulator
     @since 0.8 *)
 
-val fold_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b list
+val fold_map : f:('acc -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b list
 (** [fold_map f acc l] is a [fold_left]-like function, but it also maps the
     list to another list.
     @since 0.14 *)
 
-val fold_map2 : ('acc -> 'a -> 'b -> 'acc * 'c) -> 'acc -> 'a list -> 'b list -> 'acc * 'c list
+val fold_map2 : f:('acc -> 'a -> 'b -> 'acc * 'c) -> init:'acc -> 'a list -> 'b list -> 'acc * 'c list
 (** [fold_map2] is to [fold_map] what [List.map2] is to [List.map].
     @raise Invalid_argument if the lists do not have the same length
     @since 0.16 *)
 
-val fold_filter_map : ('acc -> 'a -> 'acc * 'b option) -> 'acc -> 'a list -> 'acc * 'b list
+val fold_filter_map : f:('acc -> 'a -> 'acc * 'b option) -> init:'acc -> 'a list -> 'acc * 'b list
 (** [fold_filter_map f acc l] is a [fold_left]-like function, but also
     generates a list of output in a way similar to {!filter_map}
     @since 0.17 *)
 
-val fold_flat_map : ('acc -> 'a -> 'acc * 'b list) -> 'acc -> 'a list -> 'acc * 'b list
+val fold_flat_map : f:('acc -> 'a -> 'acc * 'b list) -> init:'acc -> 'a list -> 'acc * 'b list
 (** [fold_flat_map f acc l] is a [fold_left]-like function, but it also maps the
     list to a list of lists that is then [flatten]'d..
     @since 0.14 *)
 
-val init : int -> (int -> 'a) -> 'a t
+val init : int -> f:(int -> 'a) -> 'a t
 (** Similar to {!Array.init}
     @since 0.6 *)
 
@@ -71,23 +71,23 @@ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
 
 val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
 
-val flat_map : ('a -> 'b t) -> 'a t -> 'b t
+val flat_map : f:('a -> 'b t) -> 'a t -> 'b t
 (** Map and flatten at the same time (safe). Evaluation order is not guaranteed. *)
 
 val flatten : 'a t t -> 'a t
 (** Safe flatten *)
 
-val product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
+val product : f:('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
 (** Cartesian product of the two lists, with the given combinator *)
 
-val fold_product : ('c -> 'a -> 'b -> 'c) -> 'c -> 'a t -> 'b t -> 'c
+val fold_product : f:('c -> 'a -> 'b -> 'c) -> init:'c -> 'a t -> 'b t -> 'c
 (** Fold on the cartesian product *)
 
 val diagonal : 'a t -> ('a * 'a) t
 (** All pairs of distinct positions of the list. [list_diagonal l] will
     return the list of [List.nth i l, List.nth j l] if [i < j]. *)
 
-val partition_map : ('a -> [<`Left of 'b | `Right of 'c | `Drop]) ->
+val partition_map : f:('a -> [<`Left of 'b | `Right of 'c | `Drop]) ->
                     'a list -> 'b list * 'c list
 (** [partition_map f l] maps [f] on [l] and gather results in lists:
     - if [f x = `Left y], adds [y] to the first list
@@ -120,10 +120,10 @@ val take_drop : int -> 'a t -> 'a t * 'a t
 (** [take_drop n l] returns [l1, l2] such that [l1 @ l2 = l] and
     [length l1 = min (length l) n] *)
 
-val take_while : ('a -> bool) -> 'a t -> 'a t
+val take_while : f:('a -> bool) -> 'a t -> 'a t
 (** @since 0.13 *)
 
-val drop_while : ('a -> bool) -> 'a t -> 'a t
+val drop_while : f:('a -> bool) -> 'a t -> 'a t
 (** @since 0.13 *)
 
 val split : int -> 'a t -> 'a t * 'a t
@@ -142,43 +142,44 @@ val last_opt : 'a t -> 'a option
 (** Last element.
     @since 0.20 *)
 
-val find_pred : ('a -> bool) -> 'a t -> 'a option
+val find_pred : f:('a -> bool) -> 'a t -> 'a option
 (** [find_pred p l] finds the first element of [l] that satisfies [p],
     or returns [None] if no element satisfies [p]
     @since 0.11 *)
 
-val find_pred_exn : ('a -> bool) -> 'a t -> 'a
+val find_pred_exn : f:('a -> bool) -> 'a t -> 'a
 (** Unsafe version of {!find_pred}
     @raise Not_found if no such element is found
     @since 0.11 *)
 
-val find_map : ('a -> 'b option) -> 'a t -> 'b option
+val find_map : f:('a -> 'b option) -> 'a t -> 'b option
 (** [find_map f l] traverses [l], applying [f] to each element. If for
     some element [x], [f x = Some y], then [Some y] is returned. Otherwise
     the call returns [None]
     @since 0.11 *)
 
-val find : ('a -> 'b option) -> 'a list -> 'b option
+(* TODO remove *)
+val find : f:('a -> 'b option) -> 'a list -> 'b option
 (** @deprecated since 0.11 in favor of {!find_map}, for the name is too confusing *)
 
-val find_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b option
+val find_mapi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
 (** Like {!find_map}, but also pass the index to the predicate function.
     @since 0.11 *)
 
-val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option
+val findi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
 (** @deprecated since 0.11 in favor of {!find_mapi}, name is too confusing
     @since 0.3.4 *)
 
-val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option
+val find_idx : f:('a -> bool) -> 'a t -> (int * 'a) option
 (** [find_idx p x] returns [Some (i,x)] where [x] is the [i]-th element of [l],
     and [p x] holds. Otherwise returns [None] *)
 
-val remove : ?eq:('a -> 'a -> bool) -> x:'a -> 'a t -> 'a t
-(** [remove ~x l] removes every instance of [x] from [l]. Tailrec.
+val remove : ?eq:('a -> 'a -> bool) -> key:'a -> 'a t -> 'a t
+(** [remove ~key l] removes every instance of [key] from [l]. Tailrec.
     @param eq equality function
     @since 0.11 *)
 
-val filter_map : ('a -> 'b option) -> 'a t -> 'b t
+val filter_map : f:('a -> 'b option) -> 'a t -> 'b t
 (** Map and remove elements at the same time *)
 
 val sorted_merge : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
@@ -224,11 +225,11 @@ val group_succ : ?eq:('a -> 'a -> bool) -> 'a list -> 'a list list
 
 (** {2 Indices} *)
 
-val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
+val mapi : f:(int -> 'a -> 'b) -> 'a t -> 'b t
 
-val iteri : (int -> 'a -> unit) -> 'a t -> unit
+val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
 
-val foldi : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b
+val foldi : f:('b -> int -> 'a -> 'b) -> init:'b -> 'a t -> 'b
 (** Fold on list, with index *)
 
 val get_at_idx : int -> 'a t -> 'a option
@@ -379,11 +380,11 @@ end
 module Traverse(M : MONAD) : sig
   val sequence_m : 'a M.t t -> 'a t M.t
 
-  val fold_m : ('b -> 'a -> 'b M.t) -> 'b -> 'a t -> 'b M.t
+  val fold_m : f:('b -> 'a -> 'b M.t) -> init:'b -> 'a t -> 'b M.t
 
-  val map_m : ('a -> 'b M.t) -> 'a t -> 'b t M.t
+  val map_m : f:('a -> 'b M.t) -> 'a t -> 'b t M.t
 
-  val map_m_par : ('a -> 'b M.t) -> 'a t -> 'b t M.t
+  val map_m_par : f:('a -> 'b M.t) -> 'a t -> 'b t M.t
   (** Same as {!map_m} but [map_m_par f (x::l)] evaluates [f x] and
       [f l] "in parallel" before combining their result (for instance
       in Lwt). *)
diff --git a/src/data/CCHashTrie.ml b/src/data/CCHashTrie.ml
index 44e3647d..b67d4f4c 100644
--- a/src/data/CCHashTrie.ml
+++ b/src/data/CCHashTrie.ml
@@ -604,7 +604,7 @@ module Make(Key : KEY)
     aux acc t
 
   (*$T
-    let l = CCList.(1 -- 10 |> map (fun x->x,x)) in  \
+    let l = CCList.(1 -- 10 |> map ~f:(fun x->x,x)) in  \
     M.of_list l \
       |> M.fold ~f:(fun acc x y -> (x,y)::acc) ~x:[] \
       |> List.sort Pervasives.compare = l
@@ -720,7 +720,7 @@ module Make(Key : KEY)
 end
 
 (*$R
-  let m = M.of_list CCList.( (501 -- 1000) @ (500 -- 1) |> map (fun i->i,i)) in
+  let m = M.of_list CCList.( (501 -- 1000) @ (500 -- 1) |> map ~f:(fun i->i,i)) in
   assert_equal ~printer:CCInt.to_string 1000 (M.cardinal m);
   assert_bool "check all get"
     (Sequence.for_all (fun i -> i = M.get_exn i m) Sequence.(1 -- 1000));
diff --git a/src/data/CCWBTree.ml b/src/data/CCWBTree.ml
index bdff0d45..acceb506 100644
--- a/src/data/CCWBTree.ml
+++ b/src/data/CCWBTree.ml
@@ -361,7 +361,7 @@ module MakeFull(K : KEY) : S with type key = K.t = struct
     with Not_found -> None
 
   (*$T
-    let m = CCList.(0 -- 1000 |> map (fun i->i,i) |> M.of_list) in \
+    let m = CCList.(0 -- 1000 |> map ~f:(fun i->i,i) |> M.of_list) in \
     List.for_all (fun i -> M.nth_exn i m = (i,i)) CCList.(0--1000)
   *)