Restore stuff that was merged out accidentally

Author: garyb

src/Data/Array.purs

@@ -1,9 +1,42 @@
-module Data.Array where
+module Data.Array
+  ( (:)
+  , singleton
+  , head
+  , tail
+  , map
+  , length
+  , indexOf
+  , lastIndexOf
+  , concat
+  , joinWith
+  , reverse
+  , drop
+  , take
+  , slice
+  , insertAt
+  , deleteAt
+  , updateAt
+  , concatMap
+  , filter
+  , isEmpty
+  , range
+  , zipWith
+  , nub
+  , nubBy
+  , sort
+  ) where
 
-import Prelude
 import Data.Maybe
 import Data.Monoid
 
+infixr 6 :
+
+(:) :: forall a. a -> [a] -> [a]
+(:) a = concat [a]
+
+singleton :: forall a. a -> [a]
+singleton a = [a]
+
 head :: forall a. [a] -> Maybe a
 head (x : _) = Just x
 head _ = Nothing
@@ -12,91 +45,90 @@ tail :: forall a. [a] -> Maybe [a]
 tail (_ : xs) = Just xs
 tail _ = Nothing
 
-map :: forall a b. (a -> b) -> [a] -> [b]
-map _ [] = []
-map f (x:xs) = f x : map f xs
+foreign import map
+  "function map (f) {\
+  \  return function (arr) {\
+  \    var l = arr.length;\
+  \    var result = new Array(l);\
+  \    for (var i = 0; i < l; i++) {\
+  \      result[i] = f(arr[i]);\
+  \    }\
+  \    return result;\
+  \  };\
+  \}" :: forall a b. (a -> b) -> [a] -> [b]
 
 foreign import length
-  "function length(xs) {\
+  "function length (xs) {\
   \  return xs.length;\
   \}" :: forall a. [a] -> Number
 
 foreign import indexOf
-  "function indexOf(l) {\
+  "function indexOf (l) {\
   \  return function (e) {\
   \    return l.indexOf(e);\
   \  };\
   \}" :: forall a. [a] -> a -> Number
 
+foreign import elem
+  "function elem(l) {\
+  \  return function (e) {\
+  \    return l.indexOf(e) !== -1;\
+  \  };\
+  \}" :: forall a. [a] -> a -> Boolean
+
 foreign import lastIndexOf
-  "function lastIndexOf(l) {\
+  "function lastIndexOf (l) {\
   \  return function (e) {\
   \    return l.lastIndexOf(e);\
   \  };\
   \}" :: forall a. [a] -> a -> Number
 
 foreign import concat
-  "function concat(l1) {\
+  "function concat (l1) {\
   \  return function (l2) {\
   \    return l1.concat(l2);\
   \  };\
   \}" :: forall a. [a] -> [a] -> [a]
 
-foreign import joinS
-  "function joinS(l) {\
-  \  return l.join();\
-  \}" :: [String] -> String
-
 foreign import joinWith
-  "function joinWith(l) {\
+  "function joinWith (l) {\
   \  return function (s) {\
   \    return l.join(s);\
   \  };\
   \}" :: [String] -> String -> String
 
-foreign import push
-  "function push(l) {\
-  \  return function (e) {\
-  \    var l1 = l.slice();\
-  \    l1.push(e); \
-  \    return l1;\
-  \  };\
-  \}" :: forall a. [a] -> a -> [a]
-
 foreign import reverse
-  "function reverse(l) {\
-  \  var l1 = l.slice();\
-  \  l1.reverse(); \
-  \  return l1;\
+  "function reverse (l) {\
+  \  return l.slice().reverse();\
   \}" :: forall a. [a] -> [a]
 
-foreign import shift
-  "function shift(l) {\
-  \  var l1 = l.slice();\
-  \  l1.shift();\
-  \  return l1;\
-  \}" :: forall a. [a] -> [a]
+foreign import drop
+  "function drop (n) {\
+  \  return function (l) {\
+  \    return l.slice(n);\
+  \  };\
+  \}" :: forall a. Number -> [a] -> [a]
+
+foreign import take
+  "function take (n) {\
+  \  return function (l) {\
+  \    return l.slice(0, n);\
+  \  };\
+  \}" :: forall a. Number -> [a] -> [a]
 
 foreign import slice
-  "function slice(s) {\
-  \  return function(e) {\
+  "function slice (s) {\
+  \  return function (e) {\
   \    return function (l) {\
   \      return l.slice(s, e);\
   \    };\
   \  };\
   \}" :: forall a. Number -> Number -> [a] -> [a]
 
-foreign import sort
-  "function sort(l) {\
-  \  var l1 = l.slice();\
-  \  l1.sort();\
-  \  return l1;\
-  \}" :: forall a. [a] -> [a]
-
 foreign import insertAt
-  "function insertAt(index) {\
-  \  return function(a) {\
-  \    return function(l) {\
+  "function insertAt (index) {\
+  \  return function (a) {\
+  \    return function (l) {\
   \      var l1 = l.slice();\
   \      l1.splice(index, 0, a);\
   \      return l1;\
@@ -105,9 +137,9 @@ foreign import insertAt
   \}":: forall a. Number -> a -> [a] -> [a]
 
 foreign import deleteAt
-  "function deleteAt(index) {\
-  \  return function(n) {\
-  \    return function(l) {\
+  "function deleteAt (index) {\
+  \  return function (n) {\
+  \    return function (l) {\
   \      var l1 = l.slice();\
   \      l1.splice(index, n);\
   \      return l1;\
@@ -116,32 +148,40 @@ foreign import deleteAt
   \}":: forall a. Number -> Number -> [a] -> [a]
 
 foreign import updateAt
-  "function updateAt(index) {\
-  \  return function(a) {\
-  \    return function(l) {\
+  "function updateAt (index) {\
+  \  return function (a) {\
+  \    return function (l) {\
   \      var l1 = l.slice();\
   \      l1[index] = a;\
   \      return l1;\
   \    }; \
   \  };\
   \}":: forall a. Number -> a -> [a] -> [a]
 
-infixr 6 :
-
-(:) :: forall a. a -> [a] -> [a]
-(:) a = concat [a]
-
-singleton :: forall a. a -> [a]
-singleton a = [a]
-
-concatMap :: forall a b. (a -> [b]) -> [a] -> [b]
-concatMap _ [] = []
-concatMap f (a:as) = f a `concat` concatMap f as
-
-filter :: forall a. (a -> Boolean) -> [a] -> [a]
-filter _ [] = []
-filter p (x:xs) | p x = x : filter p xs
-filter p (_:xs) = filter p xs
+foreign import concatMap
+  "function concatMap (f) {\
+  \  return function (arr) {\
+  \    var result = [];\
+  \    for (var i = 0, l = arr.length; i < l; i++) {\
+  \      Array.prototype.push.apply(result, f(arr[i]));\
+  \    }\
+  \    return result;\
+  \  };\
+  \}" :: forall a b. (a -> [b]) -> [a] -> [b]
+
+foreign import filter
+  "function filter (f) {\
+  \  return function (arr) {\
+  \    var n = 0;\
+  \    var result = [];\
+  \    for (var i = 0, l = arr.length; i < l; i++) {\
+  \      if (f(arr[i])) {\
+  \        result[n++] = arr[i];\
+  \      }\
+  \    }\
+  \    return result;\
+  \  };\
+  \}" :: forall a. (a -> Boolean) -> [a] -> [a]
 
 isEmpty :: forall a. [a] -> Boolean
 isEmpty [] = true
@@ -151,19 +191,19 @@ range :: Number -> Number -> [Number]
 range lo hi | lo > hi = []
 range lo hi = lo : range (lo + 1) hi
 
-zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
-zipWith f (a:as) (b:bs) = f a b : zipWith f as bs
-zipWith _ _ _ = []
-
-drop :: forall a. Number -> [a] -> [a]
-drop 0 xs = xs
-drop _ [] = []
-drop n (x:xs) = drop (n - 1) xs
-
-take :: forall a. Number -> [a] -> [a]
-take 0 _ = []
-take _ [] = []
-take n (x:xs) = x : take (n - 1) xs
+foreign import zipWith
+  "function zipWith (f) {\
+  \  return function (xs) {\
+  \    return function (ys) {\
+  \      var l = xs.length < ys.length ? xs.length : ys.length;\
+  \      var result = new Array(l);\
+  \      for (var i = 0; i < l; i++) {\
+  \        result[i] = f(xs[i])(ys[i]);\
+  \      }\
+  \      return result;\
+  \    };\
+  \  };\
+  \}" :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
 
 nub :: forall a. (Eq a) => [a] -> [a]
 nub = nubBy (==)
@@ -172,6 +212,23 @@ nubBy :: forall a. (a -> a -> Boolean) -> [a] -> [a]
 nubBy _ [] = []
 nubBy (==) (x:xs) = x : nubBy (==) (filter (\y -> not (x == y)) xs)
 
+sort :: forall a. (Ord a) => [a] -> [a]
+sort xs = sortJS comp xs
+  where
+  comp x y = case compare x y of
+    GT -> 1
+    EQ -> 0
+    LT -> -1
+
+foreign import sortJS
+  "function sortJS (f) {\
+  \  return function (l) {\
+  \    return l.slice().sort(function (x, y) {\
+  \      return f(x)(y);\
+  \    });\
+  \  };\
+  \}" :: forall a. (a -> a -> Number) -> [a] -> [a]
+
 instance showArray :: (Show a) => Show [a] where
   show xs = "[" ++ joinWith (map show xs) "," ++ "]"