Avoid uses of the polymorphic operators

benchs/run_benchs.ml

@@ -366,16 +366,16 @@ module Cache = struct
 
   let bench_fib n =
     let l =
-      [ "replacing_fib (128)", make_fib (C.replacing 128), n
+      [ "replacing_fib (128)", make_fib (C.replacing ~eq:CCInt.equal 128), n
-      ; "LRU_fib (128)", make_fib (C.lru 128), n
+      ; "LRU_fib (128)", make_fib (C.lru ~eq:CCInt.equal 128), n
-      ; "replacing_fib (16)", make_fib (C.replacing 16), n
+      ; "replacing_fib (16)", make_fib (C.replacing ~eq:CCInt.equal 16), n
-      ; "LRU_fib (16)", make_fib (C.lru 16), n
+      ; "LRU_fib (16)", make_fib (C.lru ~eq:CCInt.equal 16), n
-      ; "unbounded", make_fib (C.unbounded 32), n
+      ; "unbounded", make_fib (C.unbounded ~eq:CCInt.equal 32), n
       ]
     in
     let l = if n <= 20
-      then  [ "linear_fib (5)", make_fib (C.linear 5), n
+      then  [ "linear_fib (5)", make_fib (C.linear ~eq:CCInt.equal 5), n
-            ; "linear_fib (32)", make_fib (C.linear 32), n
+            ; "linear_fib (32)", make_fib (C.linear ~eq:CCInt.equal 32), n
             ; "dummy_fib", make_fib C.dummy, n
             ] @ l
       else l
@@ -1045,7 +1045,7 @@ module Graph = struct
 
   let dfs_event n () =
     let tbl = CCGraph.mk_table ~eq:CCInt.equal ~hash:CCInt.hash (n+10) in
-    CCGraph.Traverse.Event.dfs ~tbl ~graph:div_graph_
+    CCGraph.Traverse.Event.dfs ~tbl ~eq:CCInt.equal ~graph:div_graph_
       (Sequence.return n)
     |> Sequence.fold
       (fun acc -> function

src/core/CCArray.ml

@@ -176,8 +176,7 @@ let sort_indices cmp a =
 *)
 
 let sort_ranking cmp a =
-  let cmp_int : int -> int -> int = Pervasives.compare in
+  sort_indices compare (sort_indices cmp a)
-  sort_indices cmp_int (sort_indices cmp a)
 
 (*$= & ~cmp:(=) ~printer:Q.Print.(array int)
   [||] (sort_ranking Pervasives.compare [||])
@@ -297,10 +296,10 @@ let _lookup_exn ~cmp k a i j =
         | n when n<0 -> _lookup_rec ~cmp k a (i+1) (j-1)
         | _ -> raise Not_found  (* too high *)
 
-let lookup_exn ?(cmp=Pervasives.compare) k a =
+let lookup_exn ~cmp k a =
   _lookup_exn ~cmp k a 0 (Array.length a-1)
 
-let lookup ?(cmp=Pervasives.compare) k a =
+let lookup ~cmp k a =
   try Some (_lookup_exn ~cmp k a 0 (Array.length a-1))
   with Not_found -> None
 
@@ -314,7 +313,7 @@ let lookup ?(cmp=Pervasives.compare) k a =
   lookup 2 [| 1 |] = None
 *)
 
-let bsearch ?(cmp=Pervasives.compare) k a =
+let bsearch ~cmp k a =
   let rec aux i j =
     if i > j
     then `Just_after j
@@ -664,7 +663,7 @@ end
 
 let sort_generic (type arr)(type elt)
     (module A : MONO_ARRAY with type t = arr and type elt = elt)
-    ?(cmp=Pervasives.compare) a
+    ~cmp a
   =
   let module S = SortGeneric(A) in
   S.sort ~cmp a

src/core/CCArray.mli

@@ -119,18 +119,18 @@ val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option
     and [p x] holds. Otherwise returns [None]
     @since 0.3.4 *)
 
-val lookup : ?cmp:'a ord -> 'a -> 'a t -> int option
+val lookup : cmp:'a ord -> 'a -> 'a t -> int option
 (** Lookup the index of some value in a sorted array.
     Undefined behavior if the array is not sorted wrt [cmp].
     Complexity: [O(log (n))] (dichotomic search).
     @return [None] if the key is not present, or
       [Some i] ([i] the index of the key) otherwise *)
 
-val lookup_exn : ?cmp:'a ord -> 'a -> 'a t -> int
+val lookup_exn : cmp:'a ord -> 'a -> 'a t -> int
 (** Same as {!lookup}, but
     @raise Not_found if the key is not present *)
 
-val bsearch : ?cmp:('a -> 'a -> int) -> 'a -> 'a t ->
+val bsearch : cmp:('a -> 'a -> int) -> 'a -> 'a t ->
   [ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]
 (** [bsearch ?cmp x arr] finds the index of the object [x] in the array [arr],
     provided [arr] is {b sorted} using [cmp]. If the array is not sorted,
@@ -256,7 +256,7 @@ end
 
 val sort_generic :
   (module MONO_ARRAY with type t = 'arr and type elt = 'elt) ->
-  ?cmp:('elt -> 'elt -> int) -> 'arr -> unit
+  cmp:('elt -> 'elt -> int) -> 'arr -> unit
 (** Sort the array, without allocating (eats stack space though). Performance
     might be lower than {!Array.sort}.
     @since 0.14 *)

src/core/CCArrayLabels.mli

@@ -90,16 +90,16 @@ val find_idx : f:('a -> bool) -> 'a t -> (int * 'a) option
     and [p x] holds. Otherwise returns [None]
     @since 0.3.4 *)
 
-val lookup : ?cmp:'a ord -> key:'a -> 'a t -> int option
+val lookup : cmp:'a ord -> key:'a -> 'a t -> int option
 (** Lookup the index of some value in a sorted array.
     @return [None] if the key is not present, or
       [Some i] ([i] the index of the key) otherwise *)
 
-val lookup_exn : ?cmp:'a ord -> key:'a -> 'a t -> int
+val lookup_exn : cmp:'a ord -> key:'a -> 'a t -> int
 (** Same as {!lookup_exn}, but
     @raise Not_found if the key is not present *)
 
-val bsearch : ?cmp:('a -> 'a -> int) -> key:'a -> 'a t ->
+val bsearch : cmp:('a -> 'a -> int) -> key:'a -> 'a t ->
   [ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]
 (** [bsearch ?cmp key arr] finds the index of the object [key] in the array [arr],
     provided [arr] is {b sorted} using [cmp]. If the array is not sorted,
@@ -225,7 +225,7 @@ end
 
 val sort_generic :
   (module MONO_ARRAY with type t = 'arr and type elt = 'elt) ->
-  ?cmp:('elt -> 'elt -> int) -> 'arr -> unit
+  cmp:('elt -> 'elt -> int) -> 'arr -> unit
 (** Sort the array, without allocating (eats stack space though). Performance
     might be lower than {!Array.sort}.
     @since 0.14 *)

src/core/CCArray_slice.ml

@@ -85,6 +85,7 @@ let rec _compare cmp a1 i1 j1 a2 i2 j2 =
 let equal eq a b =
   length a = length b && _equal eq a.arr a.i a.j b.arr b.i b.j
 
+let compare_int (a : int) b = Pervasives.compare a b
 let compare cmp a b =
   _compare cmp a.arr a.i a.j b.arr b.i b.j
 
@@ -292,9 +293,8 @@ let sorted cmp a = _sorted cmp a.arr a.i a.j
 
 let sort_ranking cmp a =
   let idx = _sort_indices cmp a.arr a.i a.j in
-  let cmp_int : int -> int -> int = Pervasives.compare in
   let sort_indices cmp a = _sort_indices cmp a 0 (Array.length a) in
-  sort_indices cmp_int idx
+  sort_indices compare_int idx
 
 (*$= & ~cmp:(=) ~printer:Q.Print.(array int)
   [||] \
@@ -345,10 +345,10 @@ let find_idx p a =
   (Some (1,"c")) (find_idx ((=) "c") (make [| "a"; "b"; "c" |] 1 2))
 *)
 
-let lookup_exn ?(cmp=Pervasives.compare) k a =
+let lookup_exn ~cmp k a =
   _lookup_exn ~cmp k a.arr a.i (a.j-1) - a.i
 
-let lookup ?(cmp=Pervasives.compare) k a =
+let lookup ~cmp k a =
   try Some (_lookup_exn ~cmp k a.arr a.i (a.j-1) - a.i)
   with Not_found -> None
 
@@ -356,7 +356,7 @@ let lookup ?(cmp=Pervasives.compare) k a =
   (Some 1) (lookup "c" (make [| "a"; "b"; "c" |] 1 2))
 *)
 
-let bsearch ?(cmp=Pervasives.compare) k a =
+let bsearch ~cmp k a =
   match bsearch_ ~cmp k a.arr a.i (a.j - 1) with
     | `At m -> `At (m - a.i)
     | `Just_after m -> `Just_after (m - a.i)

src/core/CCArray_slice.mli

@@ -86,10 +86,10 @@ 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 at which the [i]-th element of [sorted cmp a] 
+    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]. 
+    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 *)
@@ -99,7 +99,7 @@ val sort_ranking : ('a -> 'a -> int) -> 'a t -> int array
     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}.
 
     In the absence of duplicate elements in [a], we also have
@@ -119,16 +119,16 @@ val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option
     and [p x] holds. Otherwise returns [None]
     @since 0.3.4 *)
 
-val lookup : ?cmp:'a ord -> 'a -> 'a t -> int option
+val lookup : cmp:'a ord -> 'a -> 'a t -> int option
 (** Lookup the index of some value in a sorted array.
     @return [None] if the key is not present, or
       [Some i] ([i] the index of the key) otherwise *)
 
-val lookup_exn : ?cmp:'a ord -> 'a -> 'a t -> int
+val lookup_exn : cmp:'a ord -> 'a -> 'a t -> int
 (** Same as {!lookup}, but
     @raise Not_found if the key is not present *)
 
-val bsearch : ?cmp:('a -> 'a -> int) -> 'a -> 'a t ->
+val bsearch : cmp:('a -> 'a -> int) -> 'a -> 'a t ->
   [ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]
 (** [bsearch ?cmp x arr] finds the index of the object [x] in the array [arr],
     provided [arr] is {b sorted} using [cmp]. If the array is not sorted,

src/core/CCInt.ml

@@ -5,7 +5,7 @@ type t = int
 
 let equal (a:int) b = a=b
 
-let compare (a:int) b = Pervasives.compare a b
+let compare a b = compare a b
 
 let hash i = i land max_int
 
@@ -247,12 +247,12 @@ let range' i j yield =
 
 
 module Infix = struct
-  let (=) = Pervasives.(=)
+  let (=) = (=)
-  let (<>) = Pervasives.(<>)
+  let (<>) = (<>)
-  let (<) = Pervasives.(<)
+  let (<) = (<)
-  let (>) = Pervasives.(>)
+  let (>) = (>)
-  let (<=) = Pervasives.(<=)
+  let (<=) = (<=)
-  let (>=) = Pervasives.(>=)
+  let (>=) = (>=)
   let (--) = range
   let (--^) = range'
 end

src/core/CCList.ml

@@ -557,7 +557,7 @@ let map_product_l f l =
     cmp_lii_unord (cartesian_product l) (map_product_l CCFun.id l))
 *)
 
-let sorted_merge ?(cmp=Pervasives.compare) l1 l2 =
+let sorted_merge ~cmp l1 l2 =
   let rec recurse cmp acc l1 l2 = match l1,l2 with
     | [], _ -> List.rev_append acc l2
     | _, [] -> List.rev_append acc l1
@@ -572,15 +572,15 @@ let sorted_merge ?(cmp=Pervasives.compare) l1 l2 =
 (*$T
   List.sort Pervasives.compare ([(( * )2); ((+)1)] <*> [10;100]) \
     = [11; 20; 101; 200]
-  sorted_merge [1;1;2] [1;2;3] = [1;1;1;2;2;3]
+  sorted_merge ~cmp:CCInt.compare [1;1;2] [1;2;3] = [1;1;1;2;2;3]
 *)
 
 (*$Q
   Q.(pair (list int) (list int)) (fun (l1,l2) -> \
-    List.length (sorted_merge l1 l2) = List.length l1 + List.length l2)
+    List.length (sorted_merge ~cmp:CCInt.compare l1 l2) = List.length l1 + List.length l2)
 *)
 
-let sort_uniq (type elt) ?(cmp=Pervasives.compare) l =
+let sort_uniq (type elt) ~cmp l =
   let module S = Set.Make(struct
       type t = elt
       let compare = cmp
@@ -589,12 +589,12 @@ let sort_uniq (type elt) ?(cmp=Pervasives.compare) l =
   S.elements set
 
 (*$T
-  sort_uniq [1;2;5;3;6;1;4;2;3] = [1;2;3;4;5;6]
+  sort_uniq ~cmp:CCInt.compare [1;2;5;3;6;1;4;2;3] = [1;2;3;4;5;6]
-  sort_uniq [] = []
+  sort_uniq ~cmp:CCInt.compare [] = []
-  sort_uniq [10;10;10;10;1;10] = [1;10]
+  sort_uniq ~cmp:CCInt.compare [10;10;10;10;1;10] = [1;10]
 *)
 
-let is_sorted ?(cmp=Pervasives.compare) l =
+let is_sorted ~cmp l =
   let rec aux cmp = function
     | [] | [_] -> true
     | x :: ((y :: _) as tail) -> cmp x y <= 0 && aux cmp tail
@@ -603,10 +603,10 @@ let is_sorted ?(cmp=Pervasives.compare) l =
 
 (*$Q
   Q.(list small_int) (fun l -> \
-    is_sorted (List.sort Pervasives.compare l))
+    is_sorted ~cmp:CCInt.compare (List.sort Pervasives.compare l))
 *)
 
-let sorted_insert ?(cmp=Pervasives.compare) ?(uniq=false) x l =
+let sorted_insert ~cmp ?(uniq=false) x l =
   let rec aux cmp uniq x left l = match l with
     | [] -> List.rev_append left [x]
     | y :: tail ->
@@ -622,20 +622,20 @@ let sorted_insert ?(cmp=Pervasives.compare) ?(uniq=false) x l =
 (*$Q
     Q.(pair small_int (list small_int)) (fun (x,l) -> \
       let l = List.sort Pervasives.compare l in \
-      is_sorted (sorted_insert ~uniq:true x l))
+      is_sorted ~cmp:CCInt.compare (sorted_insert ~cmp:CCInt.compare ~uniq:true x l))
     Q.(pair small_int (list small_int)) (fun (x,l) -> \
       let l = List.sort Pervasives.compare l in \
-      is_sorted (sorted_insert ~uniq:false x l))
+      is_sorted ~cmp:CCInt.compare (sorted_insert ~cmp:CCInt.compare ~uniq:false x l))
     Q.(pair small_int (list small_int)) (fun (x,l) -> \
       let l = List.sort Pervasives.compare l in \
-      let l' = sorted_insert ~uniq:false x l in \
+      let l' = sorted_insert ~cmp:CCInt.compare ~uniq:false x l in \
       List.length l' = List.length l + 1)
     Q.(pair small_int (list small_int)) (fun (x,l) -> \
       let l = List.sort Pervasives.compare l in \
-      List.mem x (sorted_insert x l))
+      List.mem x (sorted_insert ~cmp:CCInt.compare x l))
 *)
 
-let uniq_succ ?(eq=Pervasives.(=)) l =
+let uniq_succ ~eq l =
   let rec f acc l = match l with
     | [] -> List.rev acc
     | [x] -> List.rev (x::acc)
@@ -645,10 +645,10 @@ let uniq_succ ?(eq=Pervasives.(=)) l =
   f [] l
 
 (*$T
-  uniq_succ [1;1;2;3;1;6;6;4;6;1] = [1;2;3;1;6;4;6;1]
+  uniq_succ ~eq:CCInt.equal [1;1;2;3;1;6;6;4;6;1] = [1;2;3;1;6;4;6;1]
 *)
 
-let group_succ ?(eq=Pervasives.(=)) l =
+let group_succ ~eq l =
   let rec f ~eq acc cur l = match cur, l with
     | [], [] -> List.rev acc
     | _::_, [] -> List.rev (List.rev cur :: acc)
@@ -659,15 +659,15 @@ let group_succ ?(eq=Pervasives.(=)) l =
   f ~eq [] [] l
 
 (*$T
-  group_succ [1;2;3;1;1;2;4] = [[1]; [2]; [3]; [1;1]; [2]; [4]]
+  group_succ ~eq:CCInt.equal [1;2;3;1;1;2;4] = [[1]; [2]; [3]; [1;1]; [2]; [4]]
-  group_succ [] = []
+  group_succ ~eq:CCInt.equal [] = []
-  group_succ [1;1;1] = [[1;1;1]]
+  group_succ ~eq:CCInt.equal [1;1;1] = [[1;1;1]]
-  group_succ [1;2;2;2] = [[1]; [2;2;2]]
+  group_succ ~eq:CCInt.equal [1;2;2;2] = [[1]; [2;2;2]]
   group_succ ~eq:(fun (x,_)(y,_)-> x=y) [1, 1; 1, 2; 1, 3; 2, 0] \
     = [[1, 1; 1, 2; 1, 3]; [2, 0]]
 *)
 
-let sorted_merge_uniq ?(cmp=Pervasives.compare) l1 l2 =
+let sorted_merge_uniq ~cmp l1 l2 =
   let push ~cmp acc x = match acc with
     | [] -> [x]
     | y :: _ when cmp x y > 0 -> x :: acc
@@ -687,21 +687,21 @@ let sorted_merge_uniq ?(cmp=Pervasives.compare) l1 l2 =
   recurse ~cmp [] l1 l2
 
 (*$T
-  sorted_merge_uniq [1; 1; 2; 3; 5; 8] [1; 2; 3; 4; 6; 8; 9; 9] = [1;2;3;4;5;6;8;9]
+  sorted_merge_uniq ~cmp:CCInt.compare [1; 1; 2; 3; 5; 8] [1; 2; 3; 4; 6; 8; 9; 9] = [1;2;3;4;5;6;8;9]
 *)
 
 (*$Q
   Q.(list int) (fun l -> \
     let l = List.sort Pervasives.compare l in \
-    sorted_merge_uniq l [] = uniq_succ l)
+    sorted_merge_uniq ~cmp:CCInt.compare l [] = uniq_succ ~eq:CCInt.equal l)
   Q.(list int) (fun l -> \
     let l = List.sort Pervasives.compare l in \
-    sorted_merge_uniq [] l = uniq_succ l)
+    sorted_merge_uniq ~cmp:CCInt.compare [] l = uniq_succ ~eq:CCInt.equal l)
   Q.(pair (list int) (list int)) (fun (l1, l2) -> \
     let l1 = List.sort Pervasives.compare l1 \
     and l2 = List.sort Pervasives.compare l2 in \
-    let l3 = sorted_merge_uniq l1 l2 in \
+    let l3 = sorted_merge_uniq ~cmp:CCInt.compare l1 l2 in \
-    uniq_succ l3 = l3)
+    uniq_succ ~eq:CCInt.equal l3 = l3)
 *)
 
 let take n l =
@@ -900,7 +900,7 @@ let find_idx p l = find_mapi (fun i x -> if p x then Some (i, x) else None) l
   find_map (fun x -> if x=3 then Some "a" else None) [1;2;4;5] = None
 *)
 
-let remove ?(eq=Pervasives.(=)) ~x l =
+let remove ~eq ~x 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
@@ -909,8 +909,8 @@ let remove ?(eq=Pervasives.(=)) ~x l =
   remove' eq x [] l
 
 (*$T
-  remove ~x:1 [2;1;3;3;2;1] = [2;3;3;2]
+  remove ~eq:CCInt.equal ~x:1 [2;1;3;3;2;1] = [2;3;3;2]
-  remove ~x:10 [1;2;3] = [1;2;3]
+  remove ~eq:CCInt.equal ~x:10 [1;2;3] = [1;2;3]
 *)
 
 let filter_map f l =
@@ -972,16 +972,16 @@ let all_ok l =
   (Error "e2") (all_ok [Ok 1; Error "e2"; Error "e3"; Ok 4])
 *)
 
-let mem ?(eq=Pervasives.(=)) x l =
+let mem ~eq x l =
   let rec search eq x l = match l with
     | [] -> false
     | y::l' -> eq x y || search eq x l'
   in search eq x l
 
-let add_nodup ?(eq=Pervasives.(=)) x l =
+let add_nodup ~eq x l =
   if mem ~eq x l then l else x::l
 
-let remove_one ?(eq=Pervasives.(=)) x l =
+let remove_one ~eq x l =
   let rec remove_one ~eq x acc l = match l with
     | [] -> assert false
     | y :: tl when eq x y -> List.rev_append acc tl
@@ -998,12 +998,12 @@ let remove_one ?(eq=Pervasives.(=)) x l =
     not (mem x l) || List.length (remove_one x l) = List.length l - 1)
 *)
 
-let subset ?(eq=Pervasives.(=)) l1 l2 =
+let subset ~eq l1 l2 =
   List.for_all
     (fun t -> mem ~eq t l2)
     l1
 
-let uniq ?(eq=Pervasives.(=)) l =
+let uniq ~eq l =
   let rec uniq eq acc l = match l with
     | [] -> List.rev acc
     | x::xs when List.exists (eq x) xs -> uniq eq acc xs
@@ -1019,7 +1019,7 @@ let uniq ?(eq=Pervasives.(=)) l =
     sort_uniq l = (uniq l |> sort Pervasives.compare))
   *)
 
-let union ?(eq=Pervasives.(=)) l1 l2 =
+let union ~eq l1 l2 =
   let rec union eq acc l1 l2 = match l1 with
     | [] -> List.rev_append acc l2
     | x::xs when mem ~eq x l2 -> union eq acc xs l2
@@ -1030,7 +1030,7 @@ let union ?(eq=Pervasives.(=)) l1 l2 =
   union [1;2;4] [2;3;4;5] = [1;2;3;4;5]
 *)
 
-let inter ?(eq=Pervasives.(=)) l1 l2 =
+let inter ~eq l1 l2 =
   let rec inter eq acc l1 l2 = match l1 with
     | [] -> List.rev acc
     | x::xs when mem ~eq x l2 -> inter eq (x::acc) xs l2
@@ -1236,9 +1236,9 @@ module Assoc = struct
     | (y,z)::l' ->
       if eq x y then z else search_exn eq l' x
 
-  let get_exn ?(eq=Pervasives.(=)) x l = search_exn eq l x
+  let get_exn ~eq x l = search_exn eq l x
 
-  let get ?(eq=Pervasives.(=)) x l =
+  let get ~eq x l =
     try Some (search_exn eq l x)
     with Not_found -> None
 
@@ -1259,7 +1259,7 @@ module Assoc = struct
       then f x (Some y') (List.rev_append acc l')
       else search_set eq ((x',y')::acc) l' x ~f
 
-  let set ?(eq=Pervasives.(=)) x y l =
+  let set ~eq x y l =
     search_set eq [] l x
       ~f:(fun x _ l -> (x,y)::l)
 
@@ -1270,7 +1270,7 @@ module Assoc = struct
       = [1, "1"; 2, "2"; 3, "3"]
   *)
 
-  let mem ?(eq=Pervasives.(=)) x l =
+  let mem ~eq x l =
     try ignore (search_exn eq l x); true
     with Not_found -> false
 
@@ -1279,7 +1279,7 @@ module Assoc = struct
     not (Assoc.mem 4 [1,"1"; 2,"2"; 3, "3"])
   *)
 
-  let update ?(eq=Pervasives.(=)) ~f x l =
+  let update ~eq ~f x l =
     search_set eq [] l x
       ~f:(fun x opt_y rest ->
         match f opt_y with
@@ -1297,7 +1297,7 @@ module Assoc = struct
         ~f:(function None -> Some "3" | _ -> assert false) |> lsort)
   *)
 
-  let remove ?(eq=Pervasives.(=)) x l =
+  let remove ~eq x l =
     search_set eq [] l x
       ~f:(fun _ opt_y rest -> match opt_y with
         | None -> l  (* keep as is *)

src/core/CCList.mli

@@ -260,7 +260,7 @@ 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],
     and [p x] holds. Otherwise returns [None] *)
 
-val remove : ?eq:('a -> 'a -> bool) -> x:'a -> 'a t -> 'a t
+val remove : eq:('a -> 'a -> bool) -> x:'a -> 'a t -> 'a t
 (** [remove ~x l] removes every instance of [x] from [l]. Tailrec.
     @param eq equality function
     @since 0.11 *)
@@ -287,23 +287,23 @@ val all_ok : ('a, 'err) Result.result t -> ('a t, 'err) Result.result
     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
+val sorted_merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
 (** Merges elements from both sorted list *)
 
-val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list
+val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list
 (** Sort the list and remove duplicate elements *)
 
-val sorted_merge_uniq : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
+val sorted_merge_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
 (** [sorted_merge_uniq l1 l2] merges the sorted lists [l1] and [l2] and
     removes duplicates
     @since 0.10 *)
 
-val is_sorted : ?cmp:('a -> 'a -> int) -> 'a list -> bool
+val is_sorted : cmp:('a -> 'a -> int) -> 'a list -> bool
 (** [is_sorted l] returns [true] iff [l] is sorted (according to given order)
     @param cmp the comparison function (default [Pervasives.compare])
     @since 0.17 *)
 
-val sorted_insert : ?cmp:('a -> 'a -> int) -> ?uniq:bool -> 'a -> 'a list -> 'a list
+val sorted_insert : cmp:('a -> 'a -> int) -> ?uniq:bool -> 'a -> 'a list -> 'a list
 (** [sorted_insert x l] inserts [x] into [l] such that, if [l] was sorted,
     then [sorted_insert x l] is sorted too.
     @param uniq if true and [x] is already in sorted position in [l], then
@@ -316,14 +316,14 @@ val sorted_insert : ?cmp:('a -> 'a -> int) -> ?uniq:bool -> 'a -> 'a list -> 'a
       is_sorted (sorted_insert x l))
 *)
 
-val uniq_succ : ?eq:('a -> 'a -> bool) -> 'a list -> 'a list
+val uniq_succ : eq:('a -> 'a -> bool) -> 'a list -> 'a list
 (** [uniq_succ l] removes duplicate elements that occur one next to the other.
     Examples:
     [uniq_succ [1;2;1] = [1;2;1]]
     [uniq_succ [1;1;2] = [1;2]]
     @since 0.10 *)
 
-val group_succ : ?eq:('a -> 'a -> bool) -> 'a list -> 'a list list
+val group_succ : eq:('a -> 'a -> bool) -> 'a list -> 'a list list
 (** [group_succ ~eq l] groups together consecutive elements that are equal
     according to [eq]
     @since 0.11 *)
@@ -376,30 +376,30 @@ val remove_at_idx : int -> 'a t -> 'a t
     Those operations maintain the invariant that the list does not
     contain duplicates (if it already satisfies it) *)
 
-val add_nodup : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> 'a t
+val add_nodup : eq:('a -> 'a -> bool) -> 'a -> 'a t -> 'a t
 (** [add_nodup x set] adds [x] to [set] if it was not already present. Linear time.
     @since 0.11 *)
 
-val remove_one : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> 'a t
+val remove_one : eq:('a -> 'a -> bool) -> 'a -> 'a t -> 'a t
 (** [remove_one x set] removes one occurrence of [x] from [set]. Linear time.
     @since 0.11 *)
 
-val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> bool
+val mem : eq:('a -> 'a -> bool) -> 'a -> 'a t -> bool
 (** Membership to the list. Linear time *)
 
-val subset : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+val subset : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
 (** Test for inclusion *)
 
-val uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
+val uniq : eq:('a -> 'a -> bool) -> 'a t -> 'a t
 (** Remove duplicates w.r.t the equality predicate.
     Complexity is quadratic in the length of the list, but the order
     of elements is preserved. If you wish for a faster de-duplication
     but do not care about the order, use {!sort_uniq}*)
 
-val union : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t -> 'a t
+val union : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> 'a t
 (** List union. Complexity is product of length of inputs. *)
 
-val inter : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t -> 'a t
+val inter : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> 'a t
 (** List intersection. Complexity is product of length of inputs. *)
 
 (** {2 Other Constructors} *)
@@ -437,28 +437,28 @@ val repeat : int -> 'a t -> 'a t
 module Assoc : sig
   type ('a, 'b) t = ('a*'b) list
 
-  val get : ?eq:('a->'a->bool) -> 'a -> ('a,'b) t -> 'b option
+  val get : eq:('a->'a->bool) -> 'a -> ('a,'b) t -> 'b option
   (** Find the element *)
 
-  val get_exn : ?eq:('a->'a->bool) -> 'a -> ('a,'b) t -> 'b
+  val get_exn : eq:('a->'a->bool) -> 'a -> ('a,'b) t -> 'b
   (** Same as [get], but unsafe
       @raise Not_found if the element is not present *)
 
-  val set : ?eq:('a->'a->bool) -> 'a -> 'b -> ('a,'b) t -> ('a,'b) t
+  val set : eq:('a->'a->bool) -> 'a -> 'b -> ('a,'b) t -> ('a,'b) t
   (** Add the binding into the list (erase it if already present) *)
 
-  val mem : ?eq:('a->'a->bool) -> 'a -> ('a,_) t -> bool
+  val mem : eq:('a->'a->bool) -> 'a -> ('a,_) t -> bool
   (** [mem x l] returns [true] iff [x] is a key in [l]
       @since 0.16 *)
 
   val update :
-    ?eq:('a->'a->bool) -> f:('b option -> 'b option) -> 'a -> ('a,'b) t -> ('a,'b) t
+    eq:('a->'a->bool) -> f:('b option -> 'b option) -> 'a -> ('a,'b) t -> ('a,'b) t
   (** [update k ~f l] updates [l] on the key [k], by calling [f (get l k)]
       and removing [k] if it returns [None], mapping [k] to [v'] if it
       returns [Some v']
       @since 0.16 *)
 
-  val remove : ?eq:('a->'a->bool) -> 'a -> ('a,'b) t -> ('a,'b) t
+  val remove : eq:('a->'a->bool) -> 'a -> ('a,'b) t -> ('a,'b) t
   (** [remove x l] removes the first occurrence of [k] from [l].
       @since 0.17 *)
 end

src/core/CCListLabels.mli

@@ -178,7 +178,7 @@ 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) -> key:'a -> 'a t -> 'a t
+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 *)
@@ -186,23 +186,23 @@ val remove : ?eq:('a -> 'a -> bool) -> key:'a -> 'a t -> 'a 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
+val sorted_merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
 (** Merges elements from both sorted list *)
 
-val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list
+val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list
 (** Sort the list and remove duplicate elements *)
 
-val sorted_merge_uniq : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
+val sorted_merge_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
 (** [sorted_merge_uniq l1 l2] merges the sorted lists [l1] and [l2] and
     removes duplicates
     @since 0.10 *)
 
-val is_sorted : ?cmp:('a -> 'a -> int) -> 'a list -> bool
+val is_sorted : cmp:('a -> 'a -> int) -> 'a list -> bool
 (** [is_sorted l] returns [true] iff [l] is sorted (according to given order)
     @param cmp the comparison function (default [Pervasives.compare])
     @since 0.17 *)
 
-val sorted_insert : ?cmp:('a -> 'a -> int) -> ?uniq:bool -> 'a -> 'a list -> 'a list
+val sorted_insert : cmp:('a -> 'a -> int) -> ?uniq:bool -> 'a -> 'a list -> 'a list
 (** [sorted_insert x l] inserts [x] into [l] such that, if [l] was sorted,
     then [sorted_insert x l] is sorted too.
     @param uniq if true and [x] is already in sorted position in [l], then
@@ -215,14 +215,14 @@ val sorted_insert : ?cmp:('a -> 'a -> int) -> ?uniq:bool -> 'a -> 'a list -> 'a
       is_sorted (sorted_insert x l))
 *)
 
-val uniq_succ : ?eq:('a -> 'a -> bool) -> 'a list -> 'a list
+val uniq_succ : eq:('a -> 'a -> bool) -> 'a list -> 'a list
 (** [uniq_succ l] removes duplicate elements that occur one next to the other.
     Examples:
     [uniq_succ [1;2;1] = [1;2;1]]
     [uniq_succ [1;1;2] = [1;2]]
     @since 0.10 *)
 
-val group_succ : ?eq:('a -> 'a -> bool) -> 'a list -> 'a list list
+val group_succ : eq:('a -> 'a -> bool) -> 'a list -> 'a list list
 (** [group_succ ~eq l] groups together consecutive elements that are equal
     according to [eq]
     @since 0.11 *)
@@ -259,30 +259,30 @@ val remove_at_idx : int -> 'a t -> 'a t
     Those operations maintain the invariant that the list does not
     contain duplicates (if it already satisfies it) *)
 
-val add_nodup : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> 'a t
+val add_nodup : eq:('a -> 'a -> bool) -> 'a -> 'a t -> 'a t
 (** [add_nodup x set] adds [x] to [set] if it was not already present. Linear time.
     @since 0.11 *)
 
-val remove_one : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> 'a t
+val remove_one : eq:('a -> 'a -> bool) -> 'a -> 'a t -> 'a t
 (** [remove_one x set] removes one occurrence of [x] from [set]. Linear time.
     @since 0.11 *)
 
-val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> bool
+val mem : eq:('a -> 'a -> bool) -> 'a -> 'a t -> bool
 (** Membership to the list. Linear time *)
 
-val subset : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+val subset : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
 (** Test for inclusion *)
 
-val uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
+val uniq : eq:('a -> 'a -> bool) -> 'a t -> 'a t
 (** Remove duplicates w.r.t the equality predicate.
     Complexity is quadratic in the length of the list, but the order
     of elements is preserved. If you wish for a faster de-duplication
     but do not care about the order, use {!sort_uniq}*)
 
-val union : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t -> 'a t
+val union : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> 'a t
 (** List union. Complexity is product of length of inputs. *)
 
-val inter : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t -> 'a t
+val inter : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> 'a t
 (** List intersection. Complexity is product of length of inputs. *)
 
 (** {2 Other Constructors} *)
@@ -320,28 +320,28 @@ val repeat : int -> 'a t -> 'a t
 module Assoc : sig
   type ('a, 'b) t = ('a*'b) list
 
-  val get : ?eq:('a->'a->bool) -> 'a -> ('a,'b) t -> 'b option
+  val get : eq:('a->'a->bool) -> 'a -> ('a,'b) t -> 'b option
   (** Find the element *)
 
-  val get_exn : ?eq:('a->'a->bool) -> 'a -> ('a,'b) t -> 'b
+  val get_exn : eq:('a->'a->bool) -> 'a -> ('a,'b) t -> 'b
   (** Same as [get], but unsafe
       @raise Not_found if the element is not present *)
 
-  val set : ?eq:('a->'a->bool) -> 'a -> 'b -> ('a,'b) t -> ('a,'b) t
+  val set : eq:('a->'a->bool) -> 'a -> 'b -> ('a,'b) t -> ('a,'b) t
   (** Add the binding into the list (erase it if already present) *)
 
-  val mem : ?eq:('a->'a->bool) -> 'a -> ('a,_) t -> bool
+  val mem : eq:('a->'a->bool) -> 'a -> ('a,_) t -> bool
   (** [mem x l] returns [true] iff [x] is a key in [l]
       @since 0.16 *)
 
   val update :
-    ?eq:('a->'a->bool) -> f:('b option -> 'b option) -> 'a -> ('a,'b) t -> ('a,'b) t
+    eq:('a->'a->bool) -> f:('b option -> 'b option) -> 'a -> ('a,'b) t -> ('a,'b) t
   (** [update k ~f l] updates [l] on the key [k], by calling [f (get l k)]
       and removing [k] if it returns [None], mapping [k] to [v'] if it
       returns [Some v']
       @since 0.16 *)
 
-  val remove : ?eq:('a->'a->bool) -> 'a -> ('a,'b) t -> ('a,'b) t
+  val remove : eq:('a->'a->bool) -> 'a -> ('a,'b) t -> ('a,'b) t
   (** [remove x l] removes the first occurrence of [k] from [l].
       @since 0.17 *)
 end

src/core/CCRandom.ml

@@ -77,7 +77,7 @@ let replicate n g st =
   in aux [] n
 
 (* Sample without replacement using rejection sampling. *)
-let sample_without_replacement (type elt)  ?(compare=Pervasives.compare) k (rng:elt t) st=
+let sample_without_replacement (type elt) ~compare k (rng:elt t) st=
   let module S = Set.Make(struct type t=elt let compare = compare end) in
   let rec aux s k =
     if k <= 0 then
@@ -118,7 +118,7 @@ let _diff_list ~last l =
 let split_list i ~len st =
   if len <= 1 then invalid_arg "Random.split_list";
   if i >= len then
-    let xs = sample_without_replacement (len-1) (int_range 1 (i-1)) st in
+    let xs = sample_without_replacement ~compare (len-1) (int_range 1 (i-1)) st in
     _diff_list ( 0::xs ) ~last:i
   else
     None

src/core/CCRandom.mli

@@ -56,7 +56,7 @@ val replicate : int -> 'a t -> 'a list t
     randomly using [g] *)
 
 val sample_without_replacement:
-  ?compare:('a -> 'a -> int) -> int -> 'a t -> 'a list t
+  compare:('a -> 'a -> int) -> int -> 'a t -> 'a list t
 (** [sample_without_replacement n g] makes a list of [n] elements which are all
     generated randomly using [g] with the added constraint that none of the generated
     random values are equal

src/core/CCResult.ml

@@ -109,12 +109,12 @@ let (>|=) e f = map f e
 
 let (>>=) e f = flat_map f e
 
-let equal ?(err=Pervasives.(=)) eq a b = match a, b with
+let equal ~err eq a b = match a, b with
   | Ok x, Ok y -> eq x y
   | Error s, Error s' -> err s s'
   | _ -> false
 
-let compare ?(err=Pervasives.compare) cmp a b = match a, b with
+let compare ~err cmp a b = match a, b with
   | Ok x, Ok y -> cmp x y
   | Ok _, _  -> 1
   | _, Ok _ -> -1

src/core/CCResult.mli

@@ -96,9 +96,9 @@ val (>|=) : ('a, 'err) t -> ('a -> 'b) -> ('b, 'err) t
 
 val (>>=) : ('a, 'err) t -> ('a -> ('b, 'err) t) -> ('b, 'err) t
 
-val equal : ?err:'err equal -> 'a equal -> ('a, 'err) t equal
+val equal : err:'err equal -> 'a equal -> ('a, 'err) t equal
 
-val compare : ?err:'err ord -> 'a ord -> ('a, 'err) t ord
+val compare : err:'err ord -> 'a ord -> ('a, 'err) t ord
 
 val fold : ok:('a -> 'b) -> error:('err -> 'b) -> ('a, 'err) t -> 'b
 (** [fold ~ok ~error e] opens [e] and, if [e = Ok x], returns

src/core/CCString.ml

@@ -58,6 +58,7 @@ end
 
 let equal (a:string) b = Pervasives.(=) a b
 
+let compare_int (a : int) b = Pervasives.compare a b
 let compare = String.compare
 
 let hash s = Hashtbl.hash s
@@ -442,7 +443,7 @@ let compare_versions a b =
         | Some _, None -> 1
         | None, Some _ -> -1
         | Some x, Some y ->
-          let c = Pervasives.compare x y in
+          let c = compare_int x y in
           if c<>0 then c else cmp_rec a b
   in
   cmp_rec (Split.gen_cpy ~by:"." a) (Split.gen_cpy ~by:"." b)
@@ -480,7 +481,7 @@ let compare_natural a b =
         | NC_int _, NC_char _ -> 1
         | NC_char _, NC_int _ -> -1
         | NC_int x, NC_int y ->
-          let c = Pervasives.compare x y in
+          let c = compare_int x y in
           if c<>0 then c else cmp_rec a b
   in
   cmp_rec (chunks a) (chunks b)

src/core/CCVector.ml

@@ -297,7 +297,7 @@ let compare cmp v1 v2 =
   let n = min v1.size v2.size in
   let rec check i =
     if i = n
-    then Pervasives.compare v1.size v2.size
+    then compare v1.size v2.size
     else
       let c = cmp (get v1 i) (get v2 i) in
       if c = 0 then check (i+1) else c
@@ -513,7 +513,7 @@ let for_all p v =
     else p v.vec.(i) && check (i+1)
   in check 0
 
-let member ?(eq=Pervasives.(=)) x v =
+let member ~eq x v =
   exists (eq x) v
 
 let find_exn p v =

src/core/CCVector.mli

@@ -118,7 +118,7 @@ val shrink : ('a, rw) t -> int -> unit
 (** Shrink to the given size (remove elements above this size).
     Does nothing if the parameter is bigger than the current size. *)
 
-val member : ?eq:('a -> 'a -> bool) -> 'a -> ('a, _) t -> bool
+val member : eq:('a -> 'a -> bool) -> 'a -> ('a, _) t -> bool
 (** Is the element a member of the vector? *)
 
 val sort : ('a -> 'a -> int) -> ('a, _) t -> ('a, 'mut) t

src/data/CCCache.ml

@@ -6,7 +6,6 @@
 type 'a equal = 'a -> 'a -> bool
 type 'a hash = 'a -> int
 
-let default_eq_ = Pervasives.(=)
 let default_hash_ = Hashtbl.hash
 
 (** {2 Value interface} *)
@@ -124,7 +123,7 @@ module Linear = struct
     !r
 end
 
-let linear ?(eq=default_eq_) size =
+let linear ~eq size =
   let size = max size 1 in
   let arr = Linear.make eq size in
   { get=(fun x -> Linear.get arr x);
@@ -176,7 +175,7 @@ module Replacing = struct
   let size c () = c.c_size
 end
 
-let replacing ?(eq=default_eq_) ?(hash=default_hash_) size =
+let replacing ~eq ?(hash=default_hash_) size =
   let c = Replacing.make eq hash size in
   { get=(fun x -> Replacing.get c x);
     set=(fun x y -> Replacing.set c x y);
@@ -298,7 +297,7 @@ module LRU(X:HASH) = struct
     H.iter (fun x node -> f x node.value) c.table
 end
 
-let lru (type a) ?(eq=default_eq_) ?(hash=default_hash_) size =
+let lru (type a) ~eq ?(hash=default_hash_) size =
   let module L = LRU(struct
       type t = a
       let equal = eq
@@ -360,7 +359,7 @@ module UNBOUNDED(X:HASH) = struct
   let iter c f = H.iter f c
 end
 
-let unbounded (type a) ?(eq=default_eq_) ?(hash=default_hash_) size =
+let unbounded (type a) ~eq ?(hash=default_hash_) size =
   let module C = UNBOUNDED(struct
       type t = a
       let equal = eq

src/data/CCCache.mli

@@ -79,13 +79,13 @@ val add : ('a, 'b) t -> 'a -> 'b -> bool
 val dummy : ('a,'b) t
 (** Dummy cache, never stores any value *)
 
-val linear : ?eq:'a equal -> int -> ('a, 'b) t
+val linear : eq:'a equal -> int -> ('a, 'b) t
 (** Linear cache with the given size. It stores key/value pairs in
     an array and does linear search at every call, so it should only be used
     with small size.
     @param eq optional equality predicate for keys *)
 
-val replacing : ?eq:'a equal -> ?hash:'a hash ->
+val replacing : eq:'a equal -> ?hash:'a hash ->
   int -> ('a,'b) t
 (** Replacing cache of the given size. Equality and hash functions can be
     parametrized. It's a hash table that handles collisions by replacing
@@ -93,12 +93,12 @@ val replacing : ?eq:'a equal -> ?hash:'a hash ->
     entry with the same hash (modulo size) is added).
     Never grows wider than the given size. *)
 
-val lru : ?eq:'a equal -> ?hash:'a hash ->
+val lru : eq:'a equal -> ?hash:'a hash ->
   int -> ('a,'b) t
 (** LRU cache of the given size ("Least Recently Used": keys that have not been
     used recently are deleted first). Never grows wider than the given size. *)
 
-val unbounded : ?eq:'a equal -> ?hash:'a hash ->
+val unbounded : eq:'a equal -> ?hash:'a hash ->
   int -> ('a,'b) t
 (** Unbounded cache, backed by a Hash table. Will grow forever
     unless {!clear} is called manually. *)

src/data/CCDeque.ml

@@ -379,7 +379,7 @@ let copy d =
   assert_equal ~cmp q q'
 *)
 
-let equal ?(eq=Pervasives.(=)) a b =
+let equal ~eq a b =
   let rec aux eq a b = match a() , b() with
     | None, None -> true
     | None, Some _
@@ -387,7 +387,7 @@ let equal ?(eq=Pervasives.(=)) a b =
     | Some x, Some y -> eq x y && aux eq a b
   in aux eq (to_gen a) (to_gen b)
 
-let compare ?(cmp=Pervasives.compare) a b =
+let compare ~cmp a b =
   let rec aux cmp a b = match a() , b() with
     | None, None -> 0
     | None, Some _ -> -1

src/data/CCDeque.mli

@@ -21,13 +21,13 @@ val clear : _ t -> unit
 val is_empty : 'a t -> bool
 (** Is the deque empty? *)
 
-val equal : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+val equal : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
 (** [equal a b] checks whether [a] and [b] contain the same sequence of
     elements.
     @param eq comparison function for elements
     @since 0.13 *)
 
-val compare : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
+val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
 (** [compare a b] compares lexicographically [a] and [b]
     @param cmp comparison function for elements
     @since 0.13 *)

src/data/CCGraph.ml

@@ -56,7 +56,7 @@ type ('k, 'a) table = {
 (** Mutable set *)
 type 'a set = ('a, unit) table
 
-let mk_table (type k) ?(eq=Pervasives.(=)) ?(hash=Hashtbl.hash) size =
+let mk_table (type k) ~eq ?(hash=Hashtbl.hash) size =
   let module H = Hashtbl.Make(struct
       type t = k
       let equal = eq
@@ -68,7 +68,7 @@ let mk_table (type k) ?(eq=Pervasives.(=)) ?(hash=Hashtbl.hash) size =
   ; add=(fun k v -> H.replace tbl k v)
   }
 
-let mk_map (type k) ?(cmp=Pervasives.compare) () =
+let mk_map (type k) ~cmp () =
   let module M = Map.Make(struct
       type t = k
       let compare = cmp
@@ -160,15 +160,15 @@ module Traverse = struct
         )
       done
 
-  let generic ?(tbl=mk_table 128) ~bag ~graph seq =
+  let generic ~tbl ~bag ~graph seq =
     let tags = {
       get_tag=tbl.mem;
       set_tag=(fun v -> tbl.add v ());
     } in
     generic_tag ~tags ~bag ~graph seq
 
-  let bfs ?tbl ~graph seq =
+  let bfs ~tbl ~graph seq =
-    generic ?tbl ~bag:(mk_queue ()) ~graph seq
+    generic ~tbl ~bag:(mk_queue ()) ~graph seq
 
   let bfs_tag ~tags ~graph seq =
     generic_tag ~tags ~bag:(mk_queue()) ~graph seq
@@ -186,15 +186,15 @@ module Traverse = struct
     let bag = mk_heap ~leq:(fun (_,d1,_) (_,d2,_) -> d1 <= d2) in
     generic_tag ~tags:tags' ~bag ~graph:graph' seq'
 
-  let dijkstra ?(tbl=mk_table 128) ?dist ~graph seq =
+  let dijkstra ~tbl ?dist ~graph seq =
     let tags = {
       get_tag=tbl.mem;
       set_tag=(fun v -> tbl.add v ());
     } in
     dijkstra_tag ~tags ?dist ~graph seq
 
-  let dfs ?tbl ~graph seq =
+  let dfs ~tbl ~graph seq =
-    generic ?tbl ~bag:(mk_stack ()) ~graph seq
+    generic ~tbl ~bag:(mk_stack ()) ~graph seq
 
   let dfs_tag ~tags ~graph seq =
     generic_tag ~tags ~bag:(mk_stack()) ~graph seq
@@ -240,7 +240,7 @@ module Traverse = struct
       | (v1,_,_) :: path' ->
         eq v v1 || list_mem_ ~eq ~graph v path'
 
-    let dfs_tag ?(eq=Pervasives.(=)) ~tags ~graph seq =
+    let dfs_tag ~eq ~tags ~graph seq =
       let first = ref true in
       fun k ->
         if !first then first := false else raise Sequence_once;
@@ -279,12 +279,12 @@ module Traverse = struct
              done
           ) seq
 
-    let dfs ?(tbl=mk_table 128) ?eq ~graph seq =
+    let dfs ~tbl ~eq ~graph seq =
       let tags = {
         set_tag=(fun v -> tbl.add v ());
         get_tag=tbl.mem;
       } in
-      dfs_tag ?eq ~tags ~graph seq
+      dfs_tag ~eq ~tags ~graph seq
   end
 
   (*$R
@@ -305,8 +305,8 @@ end
 
 (** {2 Cycles} *)
 
-let is_dag ?(tbl=mk_table 128) ~graph vs =
+let is_dag ~tbl ~eq ~graph vs =
-  Traverse.Event.dfs ~tbl ~graph vs
+  Traverse.Event.dfs ~tbl ~eq ~graph vs
   |> Seq.exists_
     (function
       | `Edge (_, _, _, `Back) -> true
@@ -316,7 +316,7 @@ let is_dag ?(tbl=mk_table 128) ~graph vs =
 
 exception Has_cycle
 
-let topo_sort_tag ?(eq=Pervasives.(=)) ?(rev=false) ~tags ~graph seq =
+let topo_sort_tag ~eq ?(rev=false) ~tags ~graph seq =
   (* use DFS *)
   let l =
     Traverse.Event.dfs_tag ~eq ~tags ~graph seq
@@ -331,12 +331,12 @@ let topo_sort_tag ?(eq=Pervasives.(=)) ?(rev=false) ~tags ~graph seq =
   in
   if rev then List.rev l else l
 
-let topo_sort ?eq ?rev ?(tbl=mk_table 128) ~graph seq =
+let topo_sort ~eq ?rev ~tbl ~graph seq =
   let tags = {
     get_tag=tbl.mem;
     set_tag=(fun v -> tbl.add v ());
   } in
-  topo_sort_tag ?eq ?rev ~tags ~graph seq
+  topo_sort_tag ~eq ?rev ~tags ~graph seq
 
 (*$T
   let l = topo_sort ~graph:divisors_graph (Seq.return 42) in \
@@ -393,7 +393,7 @@ let spanning_tree_tag ~tags ~graph v =
   in
   mk_node v
 
-let spanning_tree ?(tbl=mk_table 128) ~graph v =
+let spanning_tree ~tbl ~graph v =
   let tags = {
     get_tag=tbl.mem;
     set_tag=(fun v -> tbl.add v ());
@@ -482,7 +482,7 @@ end
 
 type 'v scc_state = 'v SCC.state
 
-let scc ?(tbl=mk_table 128) ~graph seq = SCC.explore ~tbl ~graph seq
+let scc ~tbl ~graph seq = SCC.explore ~tbl ~graph seq
 
 (* example from https://en.wikipedia.org/wiki/Strongly_connected_component *)
 (*$R
@@ -541,8 +541,8 @@ module Dot = struct
 
   (** Print an enum of Full.traverse_event *)
   let pp_seq
-      ?(tbl=mk_table 128)
+      ~tbl
-      ?(eq=Pervasives.(=))
+      ~eq
       ?(attrs_v=fun _ -> [])
       ?(attrs_e=fun _ -> [])
       ?(name="graph")
@@ -598,8 +598,8 @@ module Dot = struct
     Format.fprintf out "}@]@;@?";
     ()
 
-  let pp ?tbl ?eq ?attrs_v ?attrs_e ?name ~graph fmt v =
+  let pp ~tbl ~eq ?attrs_v ?attrs_e ?name ~graph fmt v =
-    pp_seq ?tbl ?eq ?attrs_v ?attrs_e ?name ~graph fmt (Seq.return v)
+    pp_seq ~tbl ~eq ?attrs_v ?attrs_e ?name ~graph fmt (Seq.return v)
 
   let with_out filename f =
     let oc = open_out filename in
@@ -622,7 +622,7 @@ type ('v, 'e) mut_graph = {
   remove : 'v -> unit;
 }
 
-let mk_mut_tbl (type k) ?(eq=Pervasives.(=)) ?(hash=Hashtbl.hash) size =
+let mk_mut_tbl (type k) ~eq ?(hash=Hashtbl.hash) size =
   let module Tbl = Hashtbl.Make(struct
       type t = k
       let hash = hash
@@ -757,7 +757,7 @@ end
 
 (** {2 Misc} *)
 
-let of_list ?(eq=Pervasives.(=)) l =
+let of_list ~eq l =
   (fun v yield -> List.iter (fun (a,b) -> if eq a v then yield ((),b)) l)
 
 let of_fun f =

src/data/CCGraph.mli

@@ -77,10 +77,10 @@ type ('k, 'a) table = {
 (** Mutable set *)
 type 'a set = ('a, unit) table
 
-val mk_table: ?eq:('k -> 'k -> bool) -> ?hash:('k -> int) -> int -> ('k, 'a) table
+val mk_table: eq:('k -> 'k -> bool) -> ?hash:('k -> int) -> int -> ('k, 'a) table
 (** Default implementation for {!table}: a {!Hashtbl.t} *)
 
-val mk_map: ?cmp:('k -> 'k -> int) -> unit -> ('k, 'a) table
+val mk_map: cmp:('k -> 'k -> int) -> unit -> ('k, 'a) table
 (** Use a {!Map.S} underneath *)
 
 (** {2 Bags of vertices} *)
@@ -104,7 +104,7 @@ val mk_heap: leq:('a -> 'a -> bool) -> 'a bag
 module Traverse : sig
   type ('v, 'e) path = ('v * 'e * 'v) list
 
-  val generic: ?tbl:'v set ->
+  val generic: tbl:'v set ->
     bag:'v bag ->
     graph:('v, 'e) t ->
     'v sequence ->
@@ -120,7 +120,7 @@ module Traverse : sig
     'v sequence_once
   (** One-shot traversal of the graph using a tag set and the given bag *)
 
-  val dfs: ?tbl:'v set ->
+  val dfs: tbl:'v set ->
     graph:('v, 'e) t ->
     'v sequence ->
     'v sequence_once
@@ -130,7 +130,7 @@ module Traverse : sig
     'v sequence ->
     'v sequence_once
 
-  val bfs: ?tbl:'v set ->
+  val bfs: tbl:'v set ->
     graph:('v, 'e) t ->
     'v sequence ->
     'v sequence_once
@@ -140,7 +140,7 @@ module Traverse : sig
     'v sequence ->
     'v sequence_once
 
-  val dijkstra : ?tbl:'v set ->
+  val dijkstra : tbl:'v set ->
     ?dist:('e -> int) ->
     graph:('v, 'e) t ->
     'v sequence ->
@@ -174,15 +174,15 @@ module Traverse : sig
     val get_edge : ('v, 'e) t -> ('v * 'e * 'v) option
     val get_edge_kind : ('v, 'e) t -> ('v * 'e * 'v * edge_kind) option
 
-    val dfs: ?tbl:'v set ->
+    val dfs: tbl:'v set ->
-      ?eq:('v -> 'v -> bool) ->
+      eq:('v -> 'v -> bool) ->
       graph:('v, 'e) graph ->
       'v sequence ->
       ('v,'e) t sequence_once
     (** Full version of DFS.
         @param eq equality predicate on vertices *)
 
-    val dfs_tag: ?eq:('v -> 'v -> bool) ->
+    val dfs_tag: eq:('v -> 'v -> bool) ->
       tags:'v tag_set ->
       graph:('v, 'e) graph ->
       'v sequence ->
@@ -195,7 +195,8 @@ end
 (** {2 Cycles} *)
 
 val is_dag :
-  ?tbl:'v set ->
+  tbl:'v set ->
+  eq:('v -> 'v -> bool) ->
   graph:('v, _) t ->
   'v sequence ->
   bool
@@ -207,9 +208,9 @@ val is_dag :
 
 exception Has_cycle
 
-val topo_sort : ?eq:('v -> 'v -> bool) ->
+val topo_sort : eq:('v -> 'v -> bool) ->
   ?rev:bool ->
-  ?tbl:'v set ->
+  tbl:'v set ->
   graph:('v, 'e) t ->
   'v sequence ->
   'v list
@@ -224,7 +225,7 @@ val topo_sort : ?eq:('v -> 'v -> bool) ->
       [v'] occurs before [v])
     @raise Has_cycle if the graph is not a DAG *)
 
-val topo_sort_tag : ?eq:('v -> 'v -> bool) ->
+val topo_sort_tag : eq:('v -> 'v -> bool) ->
   ?rev:bool ->
   tags:'v tag_set ->
   graph:('v, 'e) t ->
@@ -245,7 +246,7 @@ module Lazy_tree : sig
   val fold_v : ('acc -> 'v -> 'acc) -> 'acc -> ('v, _) t -> 'acc
 end
 
-val spanning_tree : ?tbl:'v set ->
+val spanning_tree : tbl:'v set ->
   graph:('v, 'e) t ->
   'v ->
   ('v, 'e) Lazy_tree.t
@@ -262,7 +263,7 @@ val spanning_tree_tag : tags:'v tag_set ->
 type 'v scc_state
 (** Hidden state for {!scc} *)
 
-val scc : ?tbl:('v, 'v scc_state) table ->
+val scc : tbl:('v, 'v scc_state) table ->
   graph:('v, 'e) t ->
   'v sequence ->
   'v list sequence_once
@@ -304,8 +305,8 @@ module Dot : sig
   type vertex_state
   (** Hidden state associated to a vertex *)
 
-  val pp : ?tbl:('v,vertex_state) table ->
+  val pp : tbl:('v,vertex_state) table ->
-    ?eq:('v -> 'v -> bool) ->
+    eq:('v -> 'v -> bool) ->
     ?attrs_v:('v -> attribute list) ->
     ?attrs_e:('e -> attribute list) ->
     ?name:string ->
@@ -318,8 +319,8 @@ module Dot : sig
       @param attrs_e attributes for edges
       @param name name of the graph *)
 
-  val pp_seq : ?tbl:('v,vertex_state) table ->
+  val pp_seq : tbl:('v,vertex_state) table ->
-    ?eq:('v -> 'v -> bool) ->
+    eq:('v -> 'v -> bool) ->
     ?attrs_v:('v -> attribute list) ->
     ?attrs_e:('e -> attribute list) ->
     ?name:string ->
@@ -340,7 +341,7 @@ type ('v, 'e) mut_graph = {
   remove : 'v -> unit;
 }
 
-val mk_mut_tbl : ?eq:('v -> 'v -> bool) ->
+val mk_mut_tbl : eq:('v -> 'v -> bool) ->
   ?hash:('v -> int) ->
   int ->
   ('v, 'a) mut_graph
@@ -397,7 +398,7 @@ module Map(O : Map.OrderedType) : MAP with type vertex = O.t
 
 (** {2 Misc} *)
 
-val of_list : ?eq:('v -> 'v -> bool) -> ('v * 'v) list -> ('v, unit) t
+val of_list : eq:('v -> 'v -> bool) -> ('v * 'v) list -> ('v, unit) t
 (** [of_list l] makes a graph from a list of pairs of vertices.
     Each pair [(a,b)] is an edge from [a] to [b].
     @param eq equality used to compare vertices *)

src/data/CCIntMap.ml

@@ -22,7 +22,7 @@ end = struct
 
   let min_int = min_int
 
-  let equal (a : int) b = Pervasives.(=) a b
+  let equal = (=)
 
   let rec highest_bit_naive x m =
     if x=m then m
@@ -469,7 +469,7 @@ let compare ~cmp a b =
       then
         let c = cmp va vb in
         if c=0 then cmp_gen cmp a b else c
-      else Pervasives.compare ka kb
+      else compare ka kb
   in
   cmp_gen cmp (to_gen a) (to_gen b)
 

src/data/CCMultiSet.ml

@@ -5,6 +5,9 @@
 
 type 'a sequence = ('a -> unit) -> unit
 
+let max_int = max
+let min_int = min
+
 module type S = sig
   type elt
   type t
@@ -172,7 +175,7 @@ module Make(O : Set.OrderedType) = struct
       (fun _ n1 n2 -> match n1, n2 with
          | None, None -> assert false
          | Some n, None | None, Some n -> Some n
-         | Some n1, Some n2 -> Some (Pervasives.max n1 n2))
+         | Some n1, Some n2 -> Some (max_int n1 n2))
       m1 m2
 
   let intersection m1 m2 =
@@ -181,7 +184,7 @@ module Make(O : Set.OrderedType) = struct
          | None, None -> assert false
          | Some _, None
          | None, Some _ -> None
-         | Some n1, Some n2 -> Some (Pervasives.min n1 n2))
+         | Some n1, Some n2 -> Some (min_int n1 n2))
       m1 m2
 
   let diff m1 m2 =

src/data/CCRAL.ml

@@ -371,7 +371,7 @@ let drop_while ~f l =
 
 let take_drop n l = take n l, drop n l
 
-let equal ?(eq=Pervasives.(=)) l1 l2 =
+let equal ~eq l1 l2 =
   let rec aux ~eq l1 l2 = match l1, l2 with
     | Nil, Nil -> true
     | Cons (size1, t1, l1'), Cons (size2, t2, l2') ->
@@ -543,7 +543,7 @@ let rec of_list_map ~f l = match l with
     let y = f x in
     cons y (of_list_map ~f l')
 
-let compare ?(cmp=Pervasives.compare) l1 l2 =
+let compare ~cmp l1 l2 =
   let rec cmp_gen ~cmp g1 g2 = match g1(), g2() with
     | None, None -> 0
     | Some _, None -> 1

src/data/CCRAL.mli

@@ -109,9 +109,9 @@ val rev_map : f:('a -> 'b) -> 'a t -> 'b t
 val rev : 'a t -> 'a t
 (** Reverse the list *)
 
-val equal : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+val equal : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
 
-val compare : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
+val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
 (** Lexicographic comparison *)
 
 (** {2 Utils} *)

src/iter/CCKList.ml

@@ -422,11 +422,11 @@ let of_gen g =
   assert_equal [11;12] (drop 10 l |> take 2 |> to_list);
 *)
 
-let sort ?(cmp=Pervasives.compare) l =
+let sort ~cmp l =
   let l = to_list l in
   of_list (List.sort cmp l)
 
-let sort_uniq ?(cmp=Pervasives.compare) l =
+let sort_uniq ~cmp l =
   let l = to_list l in
   uniq (fun x y -> cmp x y = 0) (of_list (List.sort cmp l))
 

src/iter/CCKList.mli

@@ -164,12 +164,12 @@ val unzip : ('a * 'b) t -> 'a t * 'b t
 
 (** {2 Misc} *)
 
-val sort : ?cmp:'a ord -> 'a t -> 'a t
+val sort : cmp:'a ord -> 'a t -> 'a t
 (** Eager sort. Requires the iterator to be finite. O(n ln(n)) time
     and space.
     @since 0.3.3 *)
 
-val sort_uniq : ?cmp:'a ord -> 'a t -> 'a t
+val sort_uniq : cmp:'a ord -> 'a t -> 'a t
 (** Eager sort that removes duplicate values. Requires the iterator to be
     finite. O(n ln(n)) time and space.
     @since 0.3.3 *)

src/iter/CCKTree.ml

@@ -91,7 +91,7 @@ class type ['a] pset = object
   method mem : 'a -> bool
 end
 
-let set_of_cmp (type elt) ?(cmp=Pervasives.compare) () =
+let set_of_cmp (type elt) ~cmp () =
   let module S = Set.Make(struct
       type t = elt
       let compare = cmp
@@ -105,7 +105,7 @@ let set_of_cmp (type elt) ?(cmp=Pervasives.compare) () =
 let _nil () = `Nil
 let _cons x l = `Cons (x, l)
 
-let dfs ?(pset=set_of_cmp ()) t =
+let dfs ~pset t =
   let rec dfs pset stack () = match stack with
     | [] -> `Nil
     | `Explore t :: stack' ->
@@ -157,7 +157,7 @@ module FQ = struct
         x, q'
 end
 
-let bfs ?(pset=set_of_cmp ()) t =
+let bfs ~pset t =
   let rec bfs pset q () =
     if FQ.is_empty q then `Nil
     else
@@ -177,7 +177,7 @@ let rec force t : ([`Nil | `Node of 'a * 'b list] as 'b) = match t() with
   | `Nil -> `Nil
   | `Node (x, l) -> `Node (x, List.map force l)
 
-let find ?pset f t =
+let find ~pset f t =
   let rec _find_kl f l = match l() with
     | `Nil -> None
     | `Cons (x, l') ->
@@ -185,7 +185,7 @@ let find ?pset f t =
         | None -> _find_kl f l'
         | Some _ as res -> res
   in
-  _find_kl f (bfs ?pset t)
+  _find_kl f (bfs ~pset t)
 
 (** {2 Pretty-printing} *)
 

src/iter/CCKTree.mli

@@ -80,13 +80,13 @@ class type ['a] pset = object
   method mem : 'a -> bool
 end
 
-val set_of_cmp : ?cmp:('a -> 'a -> int) -> unit -> 'a pset
+val set_of_cmp : cmp:('a -> 'a -> int) -> unit -> 'a pset
 (** Build a set structure given a total ordering *)
 
-val dfs : ?pset:'a pset -> 'a t -> [ `Enter of 'a | `Exit of 'a ] klist
+val dfs : pset:'a pset -> 'a t -> [ `Enter of 'a | `Exit of 'a ] klist
 (** Depth-first traversal of the tree *)
 
-val bfs : ?pset:'a pset -> 'a t -> 'a klist
+val bfs : pset:'a pset -> 'a t -> 'a klist
 (** Breadth-first traversal of the tree *)
 
 val force : 'a t -> ([ `Nil | `Node of 'a * 'b list ] as 'b)
@@ -94,7 +94,7 @@ val force : 'a t -> ([ `Nil | `Node of 'a * 'b list ] as 'b)
     structure
     @since 0.13 *)
 
-val find : ?pset:'a pset -> ('a -> 'b option) -> 'a t -> 'b option
+val find : pset:'a pset -> ('a -> 'b option) -> 'a t -> 'b option
 (** Look for an element that maps to [Some _] *)
 
 (** {2 Pretty-printing}

src/sexp/CCSexp.ml

@@ -13,9 +13,32 @@ type t = [
 ]
 type sexp = t
 
-let equal (a : sexp) b = Pervasives.(=) a b
+let equal_string (a : string) b = Pervasives.(=) a b
 
-let compare a b = Pervasives.compare a b
+let rec equal a b = match a, b with
+  | `Atom s1, `Atom s2 ->
+    equal_string s1 s2
+  | `List l1, `List l2 ->
+    begin try List.for_all2 equal l1 l2 with Invalid_argument _ -> false end
+  | `Atom _, _ | `List _, _ -> false
+
+let compare_string (a : string) b = Pervasives.compare a b
+
+let rec compare_list a b = match a, b with
+  | [], [] -> 0
+  | [], _::_ -> -1
+  | _::_, [] -> 1
+  | x::xs, y::ys ->
+    begin match compare x y with
+      | 0 -> compare_list xs ys
+      | c -> c
+    end
+
+and compare a b = match a, b with
+  | `Atom s1, `Atom s2 -> compare_string s1 s2
+  | `List l1, `List l2 -> compare_list l1 l2
+  | `Atom _, _ -> -1
+  | `List _, _ -> 1
 
 let hash a = Hashtbl.hash a