Updates for 0.5

Author: paf31

bower.json

@@ -16,7 +16,8 @@
     "js"
   ],
   "dependencies": {
-    "purescript-maybe": "*"
+    "purescript-maybe": "*",
+    "purescript-monoid": "*"
   },
   "devDependencies": {
     "purescript-exceptions": "*",

src/Data/Array.purs

@@ -1,41 +1,8 @@
-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
+module Data.Array where
 
 import Prelude
 import Data.Maybe
-
-infixr 6 :
-
-(:) :: forall a. a -> [a] -> [a]
-(:) a = concat [a]
-
-singleton :: forall a. a -> [a]
-singleton a = [a]
+import Data.Monoid
 
 head :: forall a. [a] -> Maybe a
 head (x : _) = Just x
@@ -45,90 +12,91 @@ tail :: forall a. [a] -> Maybe [a]
 tail (_ : xs) = Just xs
 tail _ = Nothing
 
-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]
+map :: forall a b. (a -> b) -> [a] -> [b]
+map _ [] = []
+map f (x:xs) = f x : map f xs
 
 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) {\
-  \  return l.slice().reverse();\
+  "function reverse(l) {\
+  \  var l1 = l.slice();\
+  \  l1.reverse(); \
+  \  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 shift
+  "function shift(l) {\
+  \  var l1 = l.slice();\
+  \  l1.shift();\
+  \  return l1;\
+  \}" :: forall a. [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;\
@@ -137,9 +105,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;\
@@ -148,40 +116,32 @@ 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]
 
-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]
+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
 
 isEmpty :: forall a. [a] -> Boolean
 isEmpty [] = true
@@ -191,19 +151,19 @@ range :: Number -> Number -> [Number]
 range lo hi | lo > hi = []
 range lo hi = lo : range (lo + 1) hi
 
-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]
+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
 
 nub :: forall a. (Eq a) => [a] -> [a]
 nub = nubBy (==)
@@ -212,37 +172,29 @@ 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) "," ++ "]"
 
-instance monadArray :: Monad [] where
-  return = singleton
-  (>>=) = flip concatMap
-  
-instance applicativeArray :: Applicative [] where
-  pure = return
-  (<*>) = ap
-
 instance functorArray :: Functor [] where
   (<$>) = map
 
+instance applyArray :: Apply [] where
+  (<*>) = ap
+
+instance applicativeArray :: Applicative [] where
+  pure = singleton
+
+instance bindArray :: Bind [] where
+  (>>=) = flip concatMap
+
+instance monadArray :: Monad []
+
+instance semigroupArray :: Semigroup [a] where
+  (<>) = concat
+
+instance monoidArray :: Monoid [a] where
+  mempty = []
+
 instance alternativeArray :: Alternative [] where
   empty = []
   (<|>) = concat