Update build, fix some errors

Author: garyb

bower.json

@@ -25,6 +25,7 @@
     "purescript-unfoldable": "^1.0.0-rc.1"
   },
   "devDependencies": {
+    "purescript-arrays": "^1.0.0-rc.5",
     "purescript-assert": "^1.0.0-rc.1",
     "purescript-console": "^1.0.0-rc.1"
   }

src/Data/List.purs

@@ -14,8 +14,6 @@ module Data.List
 
   , singleton
   , (..), range
-  , replicate
-  , replicateM
   , some
   , many
 
@@ -142,22 +140,6 @@ range start end | start == end = singleton start
   go s e step rest | s == e = (Cons s rest)
                    | otherwise = go (s + step) e step (Cons s rest)
 
--- | Create a list with repeated instances of a value.
-replicate :: forall a. Int -> a -> List a
-replicate n value = go n Nil
-  where
-  go n rest | n <= 0 = rest
-            | otherwise = go (n - 1) (Cons value rest)
-
--- | Perform a monadic action `n` times collecting all of the results.
-replicateM :: forall m a. Monad m => Int -> m a -> m (List a)
-replicateM n m
-  | n < one = pure Nil
-  | otherwise = do
-      a <- m
-      as <- replicateM (n - one) m
-      pure (Cons a as)
-
 -- | Attempt a computation multiple times, requiring at least one success.
 -- |
 -- | The `Lazy` constraint is used to generate the result lazily, to ensure
@@ -302,7 +284,7 @@ findIndex fn = go 0
 
 -- | Find the last index for which a predicate holds.
 findLastIndex :: forall a. (a -> Boolean) -> List a -> Maybe Int
-findLastIndex fn xs = ((length xs - 1) -) <$> findIndex fn (reverse xs)
+findLastIndex fn xs = ((length xs - 1) - _) <$> findIndex fn (reverse xs)
 
 -- | Insert an element into a list at the specified index, returning a new
 -- | list or `Nothing` if the index is out-of-bounds.

src/Data/List/Lazy.purs

@@ -18,8 +18,6 @@ module Data.List.Lazy
 
   , singleton
   , (..), range
-  -- , replicate
-  -- , replicateM
   -- , some
   -- , many
   , repeat

test/Test/Data/List.purs

@@ -6,10 +6,11 @@ import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE, log)
 
 import Data.Foldable (foldMap, foldl)
-import Data.List (List(Nil, Cons), (..), length, range, foldM, unzip, zip, zipWithA, zipWith, intersectBy, intersect, (\\), deleteBy, delete, unionBy, union, nubBy, nub, groupBy, group', group, span, dropWhile, drop, takeWhile, take, sortBy, sort, catMaybes, mapMaybe, filterM, filter, concat, concatMap, reverse, alterAt, modifyAt, updateAt, deleteAt, insertAt, findLastIndex, findIndex, elemLastIndex, elemIndex, (!!), uncons, init, tail, last, head, insertBy, insert, snoc, null, replicateM, replicate, singleton, fromFoldable, transpose, mapWithIndex, (:))
+import Data.List (List(Nil, Cons), (..), length, range, foldM, unzip, zip, zipWithA, zipWith, intersectBy, intersect, (\\), deleteBy, delete, unionBy, union, nubBy, nub, groupBy, group', group, span, dropWhile, drop, takeWhile, take, sortBy, sort, catMaybes, mapMaybe, filterM, filter, concat, concatMap, reverse, alterAt, modifyAt, updateAt, deleteAt, insertAt, findLastIndex, findIndex, elemLastIndex, elemIndex, (!!), uncons, init, tail, last, head, insertBy, insert, snoc, null, singleton, fromFoldable, transpose, mapWithIndex, (:))
 import Data.Maybe (Maybe(..), isNothing, fromJust)
 import Data.Monoid.Additive (Additive(Additive))
 import Data.Tuple (Tuple(..))
+import Data.Unfoldable (replicate, replicateA, unfoldr)
 
 import Partial.Unsafe (unsafePartial)
 
@@ -34,11 +35,11 @@ testList = do
   assert $ replicate 0 "foo" == l []
   assert $ replicate (-1) "foo" == l []
 
-  log "replicateM should perform the monadic action the correct number of times"
-  assert $ replicateM 3 (Just 1) == Just (l [1, 1, 1])
-  assert $ replicateM 1 (Just 1) == Just (l [1])
-  assert $ replicateM 0 (Just 1) == Just (l [])
-  assert $ replicateM (-1) (Just 1) == Just (l [])
+  log "replicatA should perform the monadic action the correct number of times"
+  assert $ replicateA 3 (Just 1) == Just (l [1, 1, 1])
+  assert $ replicateA 1 (Just 1) == Just (l [1])
+  assert $ replicateA 0 (Just 1) == Just (l [])
+  assert $ replicateA (-1) (Just 1) == Just (l [])
 
   -- some
   -- many
@@ -295,11 +296,11 @@ testList = do
   log "foldMap should be left-to-right"
   assert $ foldMap show (range 1 5) == "12345"
 
-  log "unfoldr should be stack-safe"
-  void $ pure $ length $ Data.Unfoldable.replicate 100000 1
+  log "unfoldable replicate should be stack-safe"
+  void $ pure $ length $ replicate 100000 1
 
   log "unfoldr should maintain order"
-  assert $ (1..5) == Data.Unfoldable.unfoldr step 1
+  assert $ (1..5) == unfoldr step 1
 
   -- log "can find the first 10 primes using lazy lists"
   -- let eratos :: L.List Number -> L.List Number