Merge pull request #183 from andyarvanitis/master

Make Eq and Ord foreign functions less JS-specific

Author: hdgarrood

src/Data/Eq.js

@@ -1,11 +1,17 @@
 "use strict";
 
-exports.refEq = function (r1) {
+var refEq = function (r1) {
   return function (r2) {
     return r1 === r2;
   };
 };
 
+exports.eqBooleanImpl = refEq;
+exports.eqIntImpl = refEq;
+exports.eqNumberImpl = refEq;
+exports.eqCharImpl = refEq;
+exports.eqStringImpl = refEq;
+
 exports.eqArrayImpl = function (f) {
   return function (xs) {
     return function (ys) {

src/Data/Eq.purs

@@ -38,19 +38,19 @@ notEq x y = (x == y) == false
 infix 4 notEq as /=
 
 instance eqBoolean :: Eq Boolean where
-  eq = refEq
+  eq = eqBooleanImpl
 
 instance eqInt :: Eq Int where
-  eq = refEq
+  eq = eqIntImpl
 
 instance eqNumber :: Eq Number where
-  eq = refEq
+  eq = eqNumberImpl
 
 instance eqChar :: Eq Char where
-  eq = refEq
+  eq = eqCharImpl
 
 instance eqString :: Eq String where
-  eq = refEq
+  eq = eqStringImpl
 
 instance eqUnit :: Eq Unit where
   eq _ _ = true
@@ -64,7 +64,12 @@ instance eqArray :: Eq a => Eq (Array a) where
 instance eqRec :: (RL.RowToList row list, EqRecord list row) => Eq (Record row) where
   eq = eqRecord (RLProxy :: RLProxy list)
 
-foreign import refEq :: forall a. a -> a -> Boolean
+foreign import eqBooleanImpl :: Boolean -> Boolean -> Boolean
+foreign import eqIntImpl :: Int -> Int -> Boolean
+foreign import eqNumberImpl :: Number -> Number -> Boolean
+foreign import eqCharImpl :: Char -> Char -> Boolean
+foreign import eqStringImpl :: String -> String -> Boolean
+
 foreign import eqArrayImpl :: forall a. (a -> a -> Boolean) -> Array a -> Array a -> Boolean
 
 -- | The `Eq1` type class represents type constructors with decidable equality.

src/Data/Ord.js

@@ -1,5 +1,23 @@
 "use strict";
 
+var unsafeCompareImpl = function (lt) {
+  return function (eq) {
+    return function (gt) {
+      return function (x) {
+        return function (y) {
+          return x < y ? lt : x === y ? eq : gt;
+        };
+      };
+    };
+  };
+};
+
+exports.ordBooleanImpl = unsafeCompareImpl;
+exports.ordIntImpl = unsafeCompareImpl;
+exports.ordNumberImpl = unsafeCompareImpl;
+exports.ordStringImpl = unsafeCompareImpl;
+exports.ordCharImpl = unsafeCompareImpl;
+
 exports.ordArrayImpl = function (f) {
   return function (xs) {
     return function (ys) {

src/Data/Ord.purs

@@ -17,7 +17,6 @@ module Data.Ord
 
 import Data.Eq (class Eq, class Eq1, class EqRecord, (/=))
 import Data.Symbol (class IsSymbol, SProxy(..), reflectSymbol)
-import Data.Ord.Unsafe (unsafeCompare)
 import Data.Ordering (Ordering(..))
 import Data.Ring (class Ring, zero, one, negate)
 import Data.Unit (Unit)
@@ -39,19 +38,19 @@ class Eq a <= Ord a where
   compare :: a -> a -> Ordering
 
 instance ordBoolean :: Ord Boolean where
-  compare = unsafeCompare
+  compare = ordBooleanImpl LT EQ GT
 
 instance ordInt :: Ord Int where
-  compare = unsafeCompare
+  compare = ordIntImpl LT EQ GT
 
 instance ordNumber :: Ord Number where
-  compare = unsafeCompare
+  compare = ordNumberImpl LT EQ GT
 
 instance ordString :: Ord String where
-  compare = unsafeCompare
+  compare = ordStringImpl LT EQ GT
 
 instance ordChar :: Ord Char where
-  compare = unsafeCompare
+  compare = ordCharImpl LT EQ GT
 
 instance ordUnit :: Ord Unit where
   compare _ _ = EQ
@@ -68,6 +67,46 @@ instance ordArray :: Ord a => Ord (Array a) where
         LT -> 1
         GT -> -1
 
+foreign import ordBooleanImpl
+  :: Ordering
+  -> Ordering
+  -> Ordering
+  -> Boolean
+  -> Boolean
+  -> Ordering
+
+foreign import ordIntImpl
+  :: Ordering
+  -> Ordering
+  -> Ordering
+  -> Int
+  -> Int
+  -> Ordering
+
+foreign import ordNumberImpl
+  :: Ordering
+  -> Ordering
+  -> Ordering
+  -> Number
+  -> Number
+  -> Ordering
+
+foreign import ordStringImpl
+  :: Ordering
+  -> Ordering
+  -> Ordering
+  -> String
+  -> String
+  -> Ordering
+
+foreign import ordCharImpl
+  :: Ordering
+  -> Ordering
+  -> Ordering
+  -> Char
+  -> Char
+  -> Ordering
+
 foreign import ordArrayImpl :: forall a. (a -> a -> Int) -> Array a -> Array a -> Int
 
 instance ordOrdering :: Ord Ordering where

src/Data/Ord/Unsafe.purs

@@ -1,8 +1,12 @@
 module Data.Ord.Unsafe (unsafeCompare) where
 
+import Prim.TypeError (class Warn, Text)
 import Data.Ordering (Ordering(..))
 
-unsafeCompare :: forall a. a -> a -> Ordering
+unsafeCompare
+    :: forall a.
+       Warn (Text "'unsafeCompare' is deprecated.")
+    => a -> a -> Ordering
 unsafeCompare = unsafeCompareImpl LT EQ GT
 
 foreign import unsafeCompareImpl