Merged changes from feature/scl to master.

[simantics/platform.git] / bundles / org.simantics.scl.runtime / scl / Prelude.scl

diff --git a/bundles/org.simantics.scl.runtime/scl/Prelude.scl b/bundles/org.simantics.scl.runtime/scl/Prelude.scl
index 21658862db66f34262c1852603872ff5f25291ef..c2307014a51ceec23d4c4e7d059667d0a414a015 100644 (file)
--- a/bundles/org.simantics.scl.runtime/scl/Prelude.scl
+++ b/bundles/org.simantics.scl.runtime/scl/Prelude.scl
@@ -39,10 +39,6 @@ binding :: Serializable a => Binding a
 ***********************************************************/
 
 importJava "java.util.Arrays" where
 ***********************************************************/
 
 importJava "java.util.Arrays" where

-    @private    
-    @JavaName equals
-    equalsDoubleArray :: DoubleArray -> DoubleArray -> Boolean
-    

     @private
     @JavaName toString
     showDoubleArray :: DoubleArray -> String
     @private
     @JavaName toString
     showDoubleArray :: DoubleArray -> String


@@ -56,8 +52,6 @@ importJava "java.util.List" where
     @JavaName toArray
     listToArray :: [a] -> Array a
 
     @JavaName toArray
     listToArray :: [a] -> Array a
 

-instance Eq DoubleArray where
-    (==) = equalsDoubleArray

 instance Show DoubleArray where
     show = showDoubleArray
 
 instance Show DoubleArray where
     show = showDoubleArray
 


@@ -77,7 +71,7 @@ infixr 8  (^)
 infixl 7  (*), (/), div, mod
 infixl 6  (+), (-)
 infixl 5  (\\), (<<), (<+)
 infixl 7  (*), (/), div, mod
 infixl 6  (+), (-)
 infixl 5  (\\), (<<), (<+)

-infix  4  (==), (!=), (<), (<=), (>=), (>)
+infix  4  (!=), (<), (<=), (>=), (>)

 infixr 3  (&&), (&<&)
 infixr 2  (||), orElse, morelse
 infixr 1  (>>=), (>>), (:=)
 infixr 3  (&&), (&<&)
 infixr 2  (||), orElse, morelse
 infixr 1  (>>=), (>>), (:=)


@@ -134,23 +128,15 @@ swap (x,y) = (y,x)
 
 /// Comparison ///
 
 
 /// Comparison ///
 

-"""
-The class of types whose elements can be compared for equality.
-Method `(==)` must be implemented in instances. 
-"""
-class Eq a where
-    "Equality"
-    (==) :: a -> a -> Boolean
-    "Inequality: `a != b = not (a == b)`"
-    (!=) :: a -> a -> Boolean
-    
-    a != b = not (a == b)
+@inline
+(!=) :: a -> a -> Boolean
+a != b = not (a == b)

 
 """
 The class of linearly ordered types.
 Method `compare` must be implemented in instances. 
 """
 
 """
 The class of linearly ordered types.
 Method `compare` must be implemented in instances. 
 """

-class (Eq a) => Ord a where
+class Ord a where

     """
     `compare x y` returns a negative number, if `x` is smaller than `y`,
     a positive number, if `x` is bigger than `y` and zero if they are equal. 
     """
     `compare x y` returns a negative number, if `x` is smaller than `y`,
     a positive number, if `x` is bigger than `y` and zero if they are equal. 


@@ -220,17 +206,6 @@ minimumBy f l = snd $ foldl1 minF $ map (\x -> (f x, x)) l
   where
     minF a b = if fst a <= fst b then a else b  
 
   where
     minF a b = if fst a <= fst b then a else b  
 

-"""
-The class of types with method to compute hash codes.
-""" 
-class (Eq a) => Hashable a where
-    "`hashP v seed` computes the hash code of `v` using `seed` as a seed."
-    hashP :: a -> Integer -> Integer    
-
-"`hash v` computes the hash code of `v`"
-hash :: Hashable a => a -> Integer
-hash a = hashP a 1166136261
-

 /// Functions ///
 /*
 instance Functor ((->) a) where
 /// Functions ///
 /*
 instance Functor ((->) a) where


@@ -566,10 +541,6 @@ importJava "java.lang.Byte" where
     @JavaName parseByte
     readByte :: String -> Byte
 
     @JavaName parseByte
     readByte :: String -> Byte
 

-instance Eq Byte where
-    (==) = Java.bcmpeq
-    (!=) = Java.bcmpne
-

 instance Ord Byte where
     (<) = Java.bcmplt
     (<=) = Java.bcmple
 instance Ord Byte where
     (<) = Java.bcmplt
     (<=) = Java.bcmple


@@ -603,10 +574,6 @@ importJava "java.lang.Short" where
     @JavaName parseShort
     readShort :: String -> Short
 
     @JavaName parseShort
     readShort :: String -> Short
 

-instance Eq Short where
-    (==) = Java.scmpeq
-    (!=) = Java.scmpne
-

 instance Ord Short where
     (<) = Java.scmplt
     (<=) = Java.scmple
 instance Ord Short where
     (<) = Java.scmplt
     (<=) = Java.scmple


@@ -641,18 +608,11 @@ importJava "java.lang.Integer" where
     @JavaName parseInt
     readInteger :: String -> Integer
 
     @JavaName parseInt
     readInteger :: String -> Integer
 

-instance Eq Integer where
-    (==) = Java.icmpeq
-    (!=) = Java.icmpne
-

 instance Ord Integer where
     (<) = Java.icmplt
     (<=) = Java.icmple
     (>) = Java.icmpgt
     (>=) = Java.icmpge
 instance Ord Integer where
     (<) = Java.icmplt
     (<=) = Java.icmple
     (>) = Java.icmpgt
     (>=) = Java.icmpge

-    
-instance Hashable Integer where
-    hashP v x = Java.ixor v (Java.imul x 16777619) // prime for FNV-1 hash

 
 instance Additive Integer where
     zero = Java.iconst_0
 
 instance Additive Integer where
     zero = Java.iconst_0


@@ -690,18 +650,11 @@ importJava "java.lang.Long" where
     @JavaName parseLong
     readLong :: String -> Long
 
     @JavaName parseLong
     readLong :: String -> Long
 

-instance Eq Long where
-    (==) = Java.lcmpeq
-    (!=) = Java.lcmpne
-

 instance Ord Long where
     (<) = Java.lcmplt
     (<=) = Java.lcmple
     (>) = Java.lcmpgt
     (>=) = Java.lcmpge
 instance Ord Long where
     (<) = Java.lcmplt
     (<=) = Java.lcmple
     (>) = Java.lcmpgt
     (>=) = Java.lcmpge

-    
-instance Hashable Long where
-    hashP v x = Java.l2i (Java.lxor v (Java.lushr v 32)) + x*16777619

 
 instance Additive Long where
     zero = Java.lconst_0
 
 instance Additive Long where
     zero = Java.lconst_0


@@ -747,10 +700,6 @@ importJava "java.lang.Float" where
     "Converts 32-bit floating point number to a 32-bit integer with the same byte level representation."
     floatToIntBits :: Float -> Integer  
 
     "Converts 32-bit floating point number to a 32-bit integer with the same byte level representation."
     floatToIntBits :: Float -> Integer  
 

-instance Eq Float where
-    (==) = Java.fcmpeq
-    (!=) = Java.fcmpne
-    

 instance Ord Float where
     compare = compareFloat
     (<) = Java.fcmplt
 instance Ord Float where
     compare = compareFloat
     (<) = Java.fcmplt


@@ -758,9 +707,6 @@ instance Ord Float where
     (>) = Java.fcmpgt
     (>=) = Java.fcmpge
 
     (>) = Java.fcmpgt
     (>=) = Java.fcmpge
 

-instance Hashable Float where
-    hashP v x = hashP (floatToIntBits v) x    
-

 instance Additive Float where
     zero = Java.fconst_0
     (+) = Java.fadd
 instance Additive Float where
     zero = Java.fconst_0
     (+) = Java.fadd


@@ -828,19 +774,12 @@ importJava "java.lang.Double" where
     isNaN :: Double -> Boolean
     isInfinite :: Double -> Boolean
 
     isNaN :: Double -> Boolean
     isInfinite :: Double -> Boolean
 

-instance Eq Double where
-    (==) = Java.dcmpeq
-    (!=) = Java.dcmpne
-    

 instance Ord Double where
     compare = compareDouble
     (<) = Java.dcmplt
     (<=) = Java.dcmple
     (>) = Java.dcmpgt
 instance Ord Double where
     compare = compareDouble
     (<) = Java.dcmplt
     (<=) = Java.dcmple
     (>) = Java.dcmpgt

-    (>=) = Java.dcmpge
-
-instance Hashable Double where
-    hashP v x = hashP (doubleToLongBits v) x    
+    (>=) = Java.dcmpge 

 
 instance Additive Double where
     zero = Java.dconst_0
 
 instance Additive Double where
     zero = Java.dconst_0


@@ -899,10 +838,6 @@ importJava "java.lang.Character" where
     "Returns true, if the given character is a digit."
     isDigit :: Character -> Boolean
 
     "Returns true, if the given character is a digit."
     isDigit :: Character -> Boolean
 

-instance Eq Character where
-    (==) = Java.ccmpeq
-    (!=) = Java.ccmpne
-

 instance Ord Character where
     (<) = Java.ccmplt
     (<=) = Java.ccmple
 instance Ord Character where
     (<) = Java.ccmplt
     (<=) = Java.ccmple


@@ -1213,10 +1148,6 @@ guard patterns:
 otherwise :: Boolean
 otherwise = True
 
 otherwise :: Boolean
 otherwise = True
 

-instance Eq Boolean where
-    a == b = if a then b else not b
-    a != b = if a then not b else b
-

 instance Ord Boolean where
     compare False False = 0
     compare False True  = neg 1
 instance Ord Boolean where
     compare False False = 0
     compare False True  = neg 1


@@ -1269,10 +1200,8 @@ not a = if a then False else True
 fromJust :: Maybe a -> a
 fromJust (Just a) = a
 
 fromJust :: Maybe a -> a
 fromJust (Just a) = a
 

-deriving instance (Eq a) => Eq (Maybe a)

 deriving instance (Ord a) => Ord (Maybe a)
 deriving instance (Show a) => Show (Maybe a)
 deriving instance (Ord a) => Ord (Maybe a)
 deriving instance (Show a) => Show (Maybe a)

-deriving instance (Hashable a) => Hashable (Maybe a)

 
 instance Functor Maybe where
     fmap _ Nothing  = Nothing
 
 instance Functor Maybe where
     fmap _ Nothing  = Nothing


@@ -1346,10 +1275,8 @@ is used to hold an error value and the `Right` constructor is used to hold a cor
 """
 data Either a b = Left a | Right b
 
 """
 data Either a b = Left a | Right b
 

-deriving instance (Eq a, Eq b) => Eq (Either a b)

 deriving instance (Ord a, Ord b) => Ord (Either a b)
 deriving instance (Show a, Show b) => Show (Either a b)
 deriving instance (Ord a, Ord b) => Ord (Either a b)
 deriving instance (Show a, Show b) => Show (Either a b)

-deriving instance (Hashable a, Hashable b) => Hashable (Either a b)

 
 instance Functor (Either a) where
     fmap _ (Left x)  = Left x
 
 instance Functor (Either a) where
     fmap _ (Left x)  = Left x


@@ -1384,12 +1311,6 @@ importJava "java.lang.String" where
     @JavaName "compareTo"
     compareString :: String -> String -> Integer
     @private
     @JavaName "compareTo"
     compareString :: String -> String -> Integer
     @private

-//    @JavaName "hashCode"
-//    hashString :: String -> Integer
-    @private
-    @JavaName "equals"
-    equalsString :: String -> String -> Boolean
-    @private

     @JavaName "length"
     lengthString :: String -> Integer
 
     @JavaName "length"
     lengthString :: String -> Integer
 


@@ -1456,12 +1377,6 @@ importJava "java.lang.String" where
     @JavaName "<init>"
     string :: Vector Character -> String
 
     @JavaName "<init>"
     string :: Vector Character -> String
 

-instance Eq String where
-    (==) = equalsString
-    
-instance Hashable String where
-    hashP x v = Java.hashCode x + v*16777619
-

 instance Ord String where
     compare = compareString
     
 instance Ord String where
     compare = compareString
     


@@ -1490,15 +1405,9 @@ split pattern text = arrayToList $ splitString_ text pattern
 
 /// Tuple0 ///
 
 
 /// Tuple0 ///
 

-instance Eq () where
-    () == () = True
-

 instance Ord () where
     compare () () = 0
 
 instance Ord () where
     compare () () = 0
 

-instance Hashable () where
-    hashP () x = x
-

 instance Additive () where
     zero = ()
     () + () = ()
 instance Additive () where
     zero = ()
     () + () = ()


@@ -1518,15 +1427,9 @@ fst (x,y) = x
 snd :: (a,b) -> b
 snd (x,y) = y
 
 snd :: (a,b) -> b
 snd (x,y) = y
 

-instance (Eq a, Eq b) => Eq (a, b) where
-    (a0, b0) == (a1, b1) = a0 == a1 && b0 == b1
-

 instance (Ord a, Ord b) => Ord (a, b) where
     compare (a0, b0) (a1, b1) = compare a0 a1 &<& compare b0 b1
 
 instance (Ord a, Ord b) => Ord (a, b) where
     compare (a0, b0) (a1, b1) = compare a0 a1 &<& compare b0 b1
 

-instance (Hashable a, Hashable b) => Hashable (a, b) where
-    hashP (a,b) x = hashP b $ hashP a x
-

 instance (Additive a, Additive b) => Additive (a, b) where
     zero = (zero, zero)
     (a0, b0) + (a1, b1) = (a0+a1, b0+b1)
 instance (Additive a, Additive b) => Additive (a, b) where
     zero = (zero, zero)
     (a0, b0) + (a1, b1) = (a0+a1, b0+b1)


@@ -1539,15 +1442,9 @@ instance (Show a, Show b) => Show (a, b) where
 
 /// Tuple3 ///
 
 
 /// Tuple3 ///
 

-instance (Eq a, Eq b, Eq c) => Eq (a, b, c) where
-    (a0, b0, c0) == (a1, b1, c1) = a0 == a1 && b0 == b1 && c0 == c1
-

 instance (Ord a, Ord b, Ord c) => Ord (a, b, c) where
     compare (a0, b0, c0) (a1, b1, c1) = compare a0 a1 &<& compare b0 b1 &<& compare c0 c1
 
 instance (Ord a, Ord b, Ord c) => Ord (a, b, c) where
     compare (a0, b0, c0) (a1, b1, c1) = compare a0 a1 &<& compare b0 b1 &<& compare c0 c1
 

-instance (Hashable a, Hashable b, Hashable c) => Hashable (a, b, c) where
-    hashP (a,b,c) x = hashP c $ hashP b $ hashP a x
-

 instance (Additive a, Additive b, Additive c) => Additive (a, b, c) where
     zero = (zero, zero, zero)
     (a0, b0, c0) + (a1, b1, c1) = (a0+a1, b0+b1, c0+c1)
 instance (Additive a, Additive b, Additive c) => Additive (a, b, c) where
     zero = (zero, zero, zero)
     (a0, b0, c0) + (a1, b1, c1) = (a0+a1, b0+b1, c0+c1)


@@ -1560,16 +1457,10 @@ instance (Show a, Show b, Show c) => Show (a, b, c) where
 
 /// Tuple4 ///
 
 
 /// Tuple4 ///
 

-instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) where
-    (a0, b0, c0, d0) == (a1, b1, c1, d1) = a0 == a1 && b0 == b1 && c0 == c1 && d0 == d1
-

 instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) where
     compare (a0, b0, c0, d0) (a1, b1, c1, d1) = 
         compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1
 
 instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) where
     compare (a0, b0, c0, d0) (a1, b1, c1, d1) = 
         compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1
 

-instance (Hashable a, Hashable b, Hashable c, Hashable d) => Hashable (a, b, c, d) where
-    hashP (a,b,c,d) x = hashP d $ hashP c $ hashP b $ hashP a x
-

 instance (Additive a, Additive b, Additive c, Additive d) => Additive (a, b, c, d) where
     zero = (zero, zero, zero, zero)
     (a0, b0, c0, d0) + (a1, b1, c1, d1) = (a0+a1, b0+b1, c0+c1, d0+d1)
 instance (Additive a, Additive b, Additive c, Additive d) => Additive (a, b, c, d) where
     zero = (zero, zero, zero, zero)
     (a0, b0, c0, d0) + (a1, b1, c1, d1) = (a0+a1, b0+b1, c0+c1, d0+d1)


@@ -1582,17 +1473,9 @@ instance (Show a, Show b, Show c, Show d) => Show (a, b, c, d) where
     
 /// Tuple5 ///
 
     
 /// Tuple5 ///
 

-instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) where
-    (a0, b0, c0, d0, e0) == (a1, b1, c1, d1, e1) = 
-        a0 == a1 && b0 == b1 && c0 == c1 && d0 == d1 && e0 == e1
-

 instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) where
     compare (a0, b0, c0, d0, e0) (a1, b1, c1, d1, e1) = 
         compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1 &<& compare e0 e1
 instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) where
     compare (a0, b0, c0, d0, e0) (a1, b1, c1, d1, e1) = 
         compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1 &<& compare e0 e1

-
-instance (Hashable a, Hashable b, Hashable c, Hashable d, Hashable e) 
-       => Hashable (a, b, c, d, e) where
-    hashP (a,b,c,d,e) x = hashP e $ hashP d $ hashP c $ hashP b $ hashP a x

     
 instance (Additive a, Additive b, Additive c, Additive d, Additive e) => Additive (a, b, c, d, e) where
     zero = (zero, zero, zero, zero, zero)
     
 instance (Additive a, Additive b, Additive c, Additive d, Additive e) => Additive (a, b, c, d, e) where
     zero = (zero, zero, zero, zero, zero)


@@ -1603,13 +1486,6 @@ instance Functor ((,,,,) a b c d) where
 
 /// Lists ///
 
 
 /// Lists ///
 

-instance (Eq a) => Eq [a] where
-    a == b = lA == lB && loop 0
-      where
-        lA = length a
-        lB = length b
-        loop i = i>=lA || (a!i == b!i && loop (i+1))
-

 instance (Ord a) => Ord [a] where
     compare a b = loop 0 
       where
 instance (Ord a) => Ord [a] where
     compare a b = loop 0 
       where


@@ -1621,14 +1497,6 @@ instance (Ord a) => Ord [a] where
                  then 1
                  else compare (a!i) (b!i) &<& loop (i+1)
 
                  then 1
                  else compare (a!i) (b!i) &<& loop (i+1)
 

-instance (Hashable a) => Hashable [a] where
-    hashP a x = loop 0 x
-      where
-        lA = length a
-        loop i x = if i == lA 
-                   then x
-                   else loop (i+1) (hashP (a!i) x)
-

 instance Functor [] where
     fmap = mapList
 
 instance Functor [] where
     fmap = mapList
 


@@ -1995,7 +1863,7 @@ importJava "org.simantics.scl.runtime.Lists" where
     //build :: (forall a. a -> (a -> b -> <e> a) -> <e> a) -> <e> [b]
 
 "`elem el lst` return true, if `el` occurs in the list `lst`."
     //build :: (forall a. a -> (a -> b -> <e> a) -> <e> a) -> <e> [b]
 
 "`elem el lst` return true, if `el` occurs in the list `lst`."

-elem :: Eq a => a -> [a] -> Boolean
+elem :: a -> [a] -> Boolean

 elem el l = loop 0
   where
     len = length l
 elem el l = loop 0
   where
     len = length l


@@ -2005,7 +1873,7 @@ elem el l = loop 0
            | otherwise = False
 
 "`elemMaybe v1 (Just v2)` returns true if `v1 == v2`. `elemMaybe v1 Nothing` is always false."
            | otherwise = False
 
 "`elemMaybe v1 (Just v2)` returns true if `v1 == v2`. `elemMaybe v1 Nothing` is always false."

-elemMaybe :: Eq a => a -> Maybe a -> Boolean
+elemMaybe :: a -> Maybe a -> Boolean

 elemMaybe el m = match m with
     Just el2 -> el == el2
     Nothing -> False
 elemMaybe el m = match m with
     Just el2 -> el == el2
     Nothing -> False


@@ -2013,7 +1881,7 @@ elemMaybe el m = match m with
 """
 Computes a list that contains only elements that belongs to both input lists.
 """
 """
 Computes a list that contains only elements that belongs to both input lists.
 """

-intersect :: Eq a => [a] -> [a] -> [a]
+intersect :: [a] -> [a] -> [a]

 intersect a b = filter f a
   where
     f e = elem e b
 intersect a b = filter f a
   where
     f e = elem e b


@@ -2044,7 +1912,7 @@ tail l = if len < 2 then emptyList else subList l 1 len
     len = length l
 
 "Tries to find the given key from the list of key-value pairs and returns the corresponding value."
     len = length l
 
 "Tries to find the given key from the list of key-value pairs and returns the corresponding value."

-lookup :: Eq a => a -> [(a, b)] -> Maybe b
+lookup ::  a -> [(a, b)] -> Maybe b

 lookup el l = do
     len = length l
     loop i = if i < len 
 lookup el l = do
     len = length l
     loop i = if i < len 


@@ -2118,37 +1986,37 @@ sortBy f l = sortWith (\x y -> compare (f x) (f y)) l
 Given a list of key-value pairs, the function produces a function that finds a value
 efficiently for the given key.
 """
 Given a list of key-value pairs, the function produces a function that finds a value
 efficiently for the given key.
 """

-index :: Hashable a => [(a,b)] -> a -> Maybe b
-index = indexWith hash (==)
+index :: [(a,b)] -> a -> Maybe b
+index = indexWith hashCode (==)

 
 """
 Given a list of values and a function computing a key for each value, the function produces a function that finds a value
 effeciently for the given key.
 """
 
 """
 Given a list of values and a function computing a key for each value, the function produces a function that finds a value
 effeciently for the given key.
 """

-indexBy :: Hashable b => (a -> b) -> [a] -> b -> Maybe a
+indexBy ::  (a -> b) -> [a] -> b -> Maybe a

 indexBy f l = index [(f x, x) | x <- l]
 
 "Groups a list values by a key computed by the given function."
 indexBy f l = index [(f x, x) | x <- l]
 
 "Groups a list values by a key computed by the given function."

-groupBy :: Hashable b => (a -> <e> b) -> [a] -> <e> [(b, [a])]
-groupBy f l = groupWith hash (==) f id l
+groupBy :: (a -> <e> b) -> [a] -> <e> [(b, [a])]
+groupBy f l = groupWith hashCode (==) f id l

 
 "Groups a list of key-value pairs by the keys."
 
 "Groups a list of key-value pairs by the keys."

-group :: Hashable a => [(a,b)] -> [(a, [b])]
-group = groupWith hash (==) fst snd
+group :: [(a,b)] -> [(a, [b])]
+group = groupWith hashCode (==) fst snd

 
 "Removes duplicates (all but the first occurrence) from the list but otherwise preserves the order of the elements."
 
 "Removes duplicates (all but the first occurrence) from the list but otherwise preserves the order of the elements."

-unique :: Eq a => [a] -> [a]
+unique ::  [a] -> [a]

 unique = uniqueWith (==)
 
 "Like `unique`, but uses the given function for finding the key values used for uniqueness testing."
 unique = uniqueWith (==)
 
 "Like `unique`, but uses the given function for finding the key values used for uniqueness testing."

-uniqueBy :: Eq b => (a -> b) -> [a] -> [a]
+uniqueBy :: (a -> b) -> [a] -> [a]

 uniqueBy f = uniqueWith (\a b -> f a == f b)
 
 //sortAndUniqueBy :: Ord b => (a -> b) -> [a] -> [a]
 //sortAndUniqueBy f = map snd . uniqueWith (\a b -> fst a == fst b) . sortBy fst . map (\x -> (f x, x))
 
 "`a \\\\ b` removes all elements of `b` from the list `a`."
 uniqueBy f = uniqueWith (\a b -> f a == f b)
 
 //sortAndUniqueBy :: Ord b => (a -> b) -> [a] -> [a]
 //sortAndUniqueBy f = map snd . uniqueWith (\a b -> fst a == fst b) . sortBy fst . map (\x -> (f x, x))
 
 "`a \\\\ b` removes all elements of `b` from the list `a`."

-(\\) :: Eq a => [a] -> [a] -> [a]
+(\\) :: [a] -> [a] -> [a]

 (\\) = deleteAllBy (==)
 
 /// Dynamic ///
 (\\) = deleteAllBy (==)
 
 /// Dynamic ///