Revert "Updates for 0.7"

This reverts commit dfede46.

Author: garyb

src/Data/Array.js

@@ -211,3 +211,29 @@ exports.zipWith = function (f) {
     };
   };
 };
+
+//------------------------------------------------------------------------------
+// Folding ---------------------------------------------------------------------
+//------------------------------------------------------------------------------
+
+exports.foldrArray = function (f) {
+  return function (init) {
+    return function (xs) {
+      /* jshint maxparams: 2 */
+      return xs.reduceRight(function (acc, x) {
+        return f(x)(acc);
+      }, init);
+    };
+  };
+};
+
+exports.foldlArray = function (f) {
+  return function (init) {
+    return function (xs) {
+      /* jshint maxparams: 2 */
+      return xs.reduce(function (acc, x) {
+        return f(acc)(x);
+      }, init);
+    };
+  };
+};

src/Data/Array.purs

@@ -9,6 +9,9 @@ module Data.Array
   ( singleton
   , (..), range
   , replicate
+  , replicateM
+  , some
+  , many
 
   , null
   , length
@@ -36,6 +39,7 @@ module Data.Array
   , concat
   , concatMap
   , filter
+  , filterM
   , mapMaybe
   , catMaybes
 
@@ -65,9 +69,9 @@ module Data.Array
   , zipWithA
   , zip
   , unzip
-  ) where
 
-import Prelude
+  , foldM
+  ) where
 
 import Control.Alt (Alt, (<|>))
 import Control.Alternative (Alternative)
@@ -101,6 +105,28 @@ infix 8 ..
 -- | Create an array with repeated instances of a value.
 foreign import replicate :: forall a. Int -> a -> Array a
 
+-- | Perform a monadic action `n` times collecting all of the results.
+replicateM :: forall m a. (Monad m) => Int -> m a -> m (Array a)
+replicateM n m | n < 1 = return []
+               | otherwise = do a <- m
+                                as <- replicateM (n - 1) m
+                                return (a : as)
+
+-- | Attempt a computation multiple times, requiring at least one success.
+-- |
+-- | The `Lazy` constraint is used to generate the result lazily, to ensure
+-- | termination.
+some :: forall f a. (Alternative f, Lazy (f (Array a))) => f a -> f (Array a)
+some v = (:) <$> v <*> defer (\_ -> many v)
+
+-- | Attempt a computation multiple times, returning as many successful results
+-- | as possible (possibly zero).
+-- |
+-- | The `Lazy` constraint is used to generate the result lazily, to ensure
+-- | termination.
+many :: forall f a. (Alternative f, Lazy (f (Array a))) => f a -> f (Array a)
+many v = some v <|> pure []
+
 --------------------------------------------------------------------------------
 -- Array size ------------------------------------------------------------------
 --------------------------------------------------------------------------------
@@ -255,6 +281,20 @@ concatMap = flip bind
 -- | creating a new array.
 foreign import filter :: forall a. (a -> Boolean) -> Array a -> Array a
 
+-- | Filter where the predicate returns a monadic `Boolean`.
+-- |
+-- | ```purescript
+-- | powerSet :: forall a. [a] -> [[a]]
+-- | powerSet = filterM (const [true, false])
+-- | ```
+filterM :: forall a m. (Monad m) => (a -> m Boolean) -> Array a -> m (Array a)
+filterM p = uncons' (\_ -> pure []) \x xs -> do
+    b <- p x
+    xs' <- filterM p xs
+    return if b
+           then x : xs'
+           else xs'
+
 -- | Apply a function to each element in an array, keeping only the results
 -- | which contain a value, creating a new array.
 mapMaybe :: forall a b. (a -> Maybe b) -> Array a -> Array b
@@ -430,6 +470,18 @@ unzip :: forall a b. Array (Tuple a b) -> Tuple (Array a) (Array b)
 unzip = uncons' (\_ -> Tuple [] []) \(Tuple a b) ts -> case unzip ts of
   Tuple as bs -> Tuple (a : as) (b : bs)
 
+--------------------------------------------------------------------------------
+-- Folding ---------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+-- | Perform a fold using a monadic step function.
+foldM :: forall m a b. (Monad m) => (a -> b -> m a) -> a -> Array b -> m a
+foldM f a = uncons' (\_ -> return a) (\b bs -> f a b >>= \a' -> foldM f a' bs)
+
+foreign import foldrArray :: forall a b. (a -> b -> b) -> b -> Array a -> b
+
+foreign import foldlArray :: forall a b. (b -> a -> b) -> b -> Array a -> b
+
 --------------------------------------------------------------------------------
 -- Non-Prelude instances -------------------------------------------------------
 --------------------------------------------------------------------------------
@@ -444,5 +496,14 @@ instance alternativeArray :: Alternative Array
 
 instance monadPlusArray :: MonadPlus Array
 
+instance foldableArray :: Foldable Array where
+  foldr f z xs = foldrArray f z xs
+  foldl f z xs = foldlArray f z xs
+  foldMap f xs = foldr (\x acc -> f x <> acc) mempty xs
+
+instance traversableArray :: Traversable Array where
+  traverse f = uncons' (\_ -> pure []) (\x xs -> (:) <$> (f x) <*> traverse f xs)
+  sequence = uncons' (\_ -> pure []) (\x xs -> (:) <$> x <*> sequence xs)
+
 instance invariantArray :: Invariant Array where
   imap = imapF

src/Data/Array/ST.purs

@@ -16,8 +16,6 @@ module Data.Array.ST
   , toAssocArray
   ) where
 
-import Prelude
-
 import Control.Monad.Eff (Eff())
 import Control.Monad.ST (ST())
 import Data.Maybe (Maybe(..))
@@ -27,7 +25,7 @@ import Data.Maybe (Maybe(..))
 -- | The first type parameter represents the memory region which the array belongs to.
 -- | The second type parameter defines the type of elements of the mutable array.
 -- |
--- | The runtime representation of a value of type `STArray h a` is the same as that of `Array a`,
+-- | The runtime representation of a value of type `STArray h a` is the same as that of `[a]`,
 -- | except that mutation is allowed.
 foreign import data STArray :: * -> * -> *
 

src/Data/Array/Unsafe.purs

@@ -5,8 +5,6 @@
 
 module Data.Array.Unsafe where
 
-import Prelude
-
 import Data.Array (length, slice)
 
 -- | Find the element of an array at the specified index.

test/Test/Data/Array.purs

@@ -1,7 +1,5 @@
 module Test.Data.Array (testArray) where
 
-import Prelude
-
 import Console (log)
 import Data.Array
 import Data.Maybe (Maybe(..), isNothing)

test/Test/Data/Array/ST.purs

@@ -1,7 +1,5 @@
 module Test.Data.Array.ST (testArrayST) where
 
-import Prelude
-
 import Console (log, print)
 import Control.Monad.Eff (runPure)
 import Control.Monad.ST (runST)

test/Test/Data/Array/Unsafe.purs

@@ -1,7 +1,5 @@
 module Test.Data.Array.Unsafe (testArrayUnsafe) where
 
-import Prelude
-
 import Console (log)
 import Data.Array.Unsafe
 import Test.Assert (assert)

test/Test/Main.purs

@@ -1,7 +1,5 @@
 module Test.Main where
 
-import Prelude
-
 import Test.Data.Array
 import Test.Data.Array.ST
 import Test.Data.Array.Unsafe