Updates for Arrays

Author: paf31

src/Control/Alt.purs

@@ -2,8 +2,6 @@
 
 module Control.Alt where
 
-infixl 3 <|>
-
 -- | The `Alt` type class identifies an associative operation on a type
 -- | constructor.  It is similar to `Semigroup`, except that it applies to
 -- | types of kind `* -> *`, like `Array` or `List`, rather than concrete types
@@ -17,4 +15,10 @@ infixl 3 <|>
 -- | For example, the `Array` (`[]`) type is an instance of `Alt`, where
 -- | `(<|>)` is defined to be concatenation.
 class (Functor f) <= Alt f where
-  (<|>) :: forall a. f a -> f a -> f a
+  alt :: forall a. f a -> f a -> f a
+
+infixl 3 <|>
+
+-- | An infix version of `alt`.
+(<|>) :: forall f a. (Alt f) => f a -> f a -> f a
+(<|>) = alt

src/Control/Alternative.purs

@@ -17,18 +17,3 @@ import Control.Plus
 -- | - Annihilation: `empty <*> f = empty`
 class (Applicative f, Plus f) <= Alternative f
 
--- | 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 [a])) => f a -> f [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 [a])) => f a -> f [a]
-many v = some v <|> pure []
-

src/Control/Extend.purs

@@ -18,10 +18,14 @@ infixr 1 =<=
 -- |
 -- | - Associativity: `extend f <<< extend g = extend (f <<< extend g)`
 class (Functor w) <= Extend w where
-  (<<=) :: forall b a. (w a -> b) -> w a -> w b
+  extend :: forall b a. (w a -> b) -> w a -> w b
 
 instance extendArr :: (Semigroup w) => Extend ((->) w) where
-  (<<=) f g w = f \w' -> g (w <> w')
+  extend f g w = f \w' -> g (w <> w')
+
+-- | An infix version of `extend`
+(<<=) :: forall w a b. (Extend w) => (w a -> b) -> w a -> w b
+(<<=) = extend
 
 -- | A version of `(<<=)` with its arguments flipped.
 (=>>) :: forall b a w. (Extend w) => w a -> (w a -> b) -> w b
@@ -35,12 +39,8 @@ instance extendArr :: (Semigroup w) => Extend ((->) w) where
 (=<=) :: forall b a w c. (Extend w) => (w b -> c) -> (w a -> b) -> w a -> c
 (=<=) f g w = f (g <<= w)
 
--- | An alias for `(<<=)`.
-extend :: forall b a w. (Extend w) => (w a -> b) -> w a -> w b
-extend = (<<=)
-
 -- | Duplicate a comonadic context.
 -- |
 -- | `duplicate` is dual to `Control.Bind.join`.
 duplicate :: forall a w. (Extend w) => w a -> w (w a)
-duplicate w = id <<= w
+duplicate = extend id

src/Control/Monad.purs

@@ -2,20 +2,6 @@
 
 module Control.Monad where
 
-import Data.Int (Int())
-
--- | Perform a monadic action `n` times collecting all of the results.
-replicateM :: forall m a. (Monad m) => Int -> m a -> m [a]
-replicateM n m | n < one   = return []
-               | otherwise = do a <- m
-                                as <- replicateM (n - one) m
-                                return (a : as)
-
--- | Perform a fold using a monadic step function.
-foldM :: forall m a b. (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
-foldM _ a [] = return a
-foldM f a (b:bs) = f a b >>= \a' -> foldM f a' bs
-
 -- | Perform a monadic action when a condition is true.
 when :: forall m. (Monad m) => Boolean -> m Unit -> m Unit
 when true m = m
@@ -25,20 +11,3 @@ when false _ = return unit
 unless :: forall m. (Monad m) => Boolean -> m Unit -> m Unit
 unless false m = m
 unless true _ = return unit
-
--- | Filter where the predicate returns a monadic `Boolean`.
--- |
--- | For example:
--- |
--- | ```purescript
--- | powerSet :: forall a. [a] -> [[a]]
--- | powerSet = filterM (const [true, false])
--- | ```
-filterM :: forall a m. (Monad m) => (a -> m Boolean) -> [a] -> m [a]
-filterM _ [] = return []
-filterM p (x:xs) = do
-  b <- p x
-  xs' <- filterM p xs
-  return $ if b
-           then x : xs'
-           else xs'