Updates for 0.7

Author: paf31

src/Data/Array.js

@@ -211,29 +211,3 @@ 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,9 +9,6 @@ module Data.Array
   ( singleton
   , (..), range
   , replicate
-  , replicateM
-  , some
-  , many
 
   , null
   , length
@@ -39,7 +36,6 @@ module Data.Array
   , concat
   , concatMap
   , filter
-  , filterM
   , mapMaybe
   , catMaybes
 
@@ -69,10 +65,10 @@ module Data.Array
   , zipWithA
   , zip
   , unzip
-
-  , foldM
   ) where
 
+import Prelude
+
 import Control.Alt (Alt, (<|>))
 import Control.Alternative (Alternative)
 import Control.Lazy (Lazy, defer)
@@ -105,28 +101,6 @@ 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 ------------------------------------------------------------------
 --------------------------------------------------------------------------------
@@ -281,20 +255,6 @@ 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
@@ -470,18 +430,6 @@ 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 -------------------------------------------------------
 --------------------------------------------------------------------------------
@@ -496,14 +444,5 @@ 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,6 +16,8 @@ module Data.Array.ST
   , toAssocArray
   ) where
 
+import Prelude
+
 import Control.Monad.Eff (Eff())
 import Control.Monad.ST (ST())
 import Data.Maybe (Maybe(..))
@@ -25,7 +27,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 `[a]`,
+-- | The runtime representation of a value of type `STArray h a` is the same as that of `Array a`,
 -- | except that mutation is allowed.
 foreign import data STArray :: * -> * -> *
 

src/Data/Array/Unsafe.purs

@@ -5,6 +5,8 @@
 
 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,5 +1,7 @@
 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,5 +1,7 @@
 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,5 +1,7 @@
 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,5 +1,7 @@
 module Test.Main where
 
+import Prelude
+
 import Test.Data.Array
 import Test.Data.Array.ST
 import Test.Data.Array.Unsafe