[Belt] Add MakeHashable/MakeHashableU

Author: chenglou

jscomp/others/belt_Id.ml

@@ -73,10 +73,9 @@ let comparableU
     end) in 
   (module N : Comparable with type t = key)
 
-
 let comparable cmp =
   comparableU (fun[@bs] a b -> cmp a b)
-    
+
 module type Hashable = sig 
   type identity 
   type t 
@@ -86,9 +85,9 @@ end
 
 type ('key, 'id) hashable = (module Hashable with type t = 'key and type identity = 'id)
 
-module MakeHashable (M : sig
+module MakeHashableU (M : sig
    type t
-   val hash : t -> int  [@bs]
+   val hash : t -> int [@bs]
    val eq : t -> t -> bool [@bs]
   end) =
 struct
@@ -97,9 +96,21 @@ struct
   let hash = M.hash
   let eq = M.eq
 end
-  
+
+module MakeHashable (M : sig
+   type t
+   val hash : t -> int
+   val eq : t -> t -> bool
+  end) =
+struct
+  type identity
+  type t = M.t
+  let hash = (fun[@bs] a -> M.hash a)
+  let eq = (fun[@bs] a b -> M.eq a b)
+end
+
 let hashableU (type key) ~hash ~eq = 
-  let module N = MakeHashable(struct 
+  let module N = MakeHashableU(struct 
     type t = key 
     let hash = hash 
     let eq = eq 

jscomp/others/belt_Id.mli

@@ -35,21 +35,21 @@
 
 
 
-type ('a, 'id) hash = 'a -> int [@bs]
+type ('a, 'id) hash
 (** [('a, 'id) hash]
 
     Its runtime represenation is a [hash] function, but signed with a 
     type parameter, so that different hash functions type mismatch
 *) 
 
-type ('a, 'id) eq = 'a -> 'a -> bool [@bs]
+type ('a, 'id) eq
 (** [('a, 'id) eq]
  
     Its runtime represenation is an [eq] function, but signed with a 
     type parameter, so that different hash functions type mismatch
 *) 
 
-type ('a, 'id) cmp = 'a -> 'a -> int [@bs]
+type ('a, 'id) cmp
 (** [('a,'id) cmp]
   
     Its runtime representation is a [cmp] function, but signed with a 
@@ -78,31 +78,25 @@ module MakeComparableU :
   functor (M : sig 
     type t 
     val cmp : t -> t -> int [@bs] 
-  end) ->
-    sig 
-      type identity
-      type t = M.t 
-      val cmp : M.t -> M.t -> int [@bs] 
-    end
+  end) -> 
+  Comparable with type t = M.t
 
 module MakeComparable : 
   functor (M : sig 
     type t 
     val cmp : t -> t -> int 
   end) ->
-    sig 
-      type identity
-      type t = M.t 
-      val cmp : M.t -> M.t -> int [@bs] 
-    end
+  Comparable with type t = M.t
 
 val comparableU:
   ('a -> 'a -> int [@bs]) ->
   (module Comparable with type t = 'a)
+[@@ocaml.deprecated "Use the MakeComparableU functor API instead"]
 
 val comparable:
   ('a -> 'a -> int) -> 
   (module Comparable with type t = 'a)
+[@@ocaml.deprecated "Use the MakeComparable functor API instead"]
 
 module type Hashable = sig 
   type identity
@@ -124,17 +118,33 @@ type ('key, 'id) hashable =
     mismatch if they use different comparison function
 *)
 
-                            
+module MakeHashableU : 
+  functor (M : sig 
+    type t 
+     val hash : t -> int [@bs]
+     val eq : t -> t -> bool [@bs]
+  end) ->
+  Hashable with type t = M.t
+
+module MakeHashable : 
+  functor (M : sig 
+    type t 
+     val hash : t -> int
+     val eq : t -> t -> bool
+  end) ->
+  Hashable with type t = M.t
 
 val hashableU :
   hash:('a -> int [@bs]) ->
   eq:('a -> 'a -> bool [@bs]) ->
   (module Hashable with type t = 'a)
-  
+[@@ocaml.deprecated "Use the MakeHashableU functor API instead"]
+
 val hashable :
   hash:('a -> int) ->
   eq:('a -> 'a -> bool ) ->
   (module Hashable with type t = 'a)
+[@@ocaml.deprecated "Use the MakeHashable functor API instead"]
 
 
 

lib/js/belt_Id.js

@@ -2,12 +2,48 @@
 
 var Curry = require("./curry.js");
 
+function MakeComparableU(M) {
+  var cmp = M[/* cmp */0];
+  return /* module */[/* cmp */cmp];
+}
+
+function MakeComparable(M) {
+  var cmp = function (a, b) {
+    return Curry._2(M[/* cmp */0], a, b);
+  };
+  return /* module */[/* cmp */cmp];
+}
+
 function comparableU(cmp) {
   return /* module */[/* cmp */cmp];
 }
 
 function comparable(cmp) {
-  return comparableU(Curry.__2(cmp));
+  var M = /* module */[/* cmp */Curry.__2(cmp)];
+  var cmp$1 = M[/* cmp */0];
+  return /* module */[/* cmp */cmp$1];
+}
+
+function MakeHashableU(M) {
+  var hash = M[/* hash */0];
+  var eq = M[/* eq */1];
+  return /* module */[
+          /* hash */hash,
+          /* eq */eq
+        ];
+}
+
+function MakeHashable(M) {
+  var hash = function (a) {
+    return Curry._1(M[/* hash */0], a);
+  };
+  var eq = function (a, b) {
+    return Curry._2(M[/* eq */1], a, b);
+  };
+  return /* module */[
+          /* hash */hash,
+          /* eq */eq
+        ];
 }
 
 function hashableU(hash, eq) {
@@ -18,11 +54,22 @@ function hashableU(hash, eq) {
 }
 
 function hashable(hash, eq) {
-  return hashableU(Curry.__1(hash), Curry.__2(eq));
+  var M_000 = Curry.__1(hash);
+  var M_001 = Curry.__2(eq);
+  var hash$1 = M_000;
+  var eq$1 = M_001;
+  return /* module */[
+          /* hash */hash$1,
+          /* eq */eq$1
+        ];
 }
 
+exports.MakeComparableU = MakeComparableU;
+exports.MakeComparable = MakeComparable;
 exports.comparableU = comparableU;
 exports.comparable = comparable;
+exports.MakeHashableU = MakeHashableU;
+exports.MakeHashable = MakeHashable;
 exports.hashableU = hashableU;
 exports.hashable = hashable;
 /* No side effect */