Started updating for changes to hierarchy.

Author: joneshf

src/Control/Applicative.purs

@@ -1,24 +1,25 @@
 module Control.Apply where
 
-  -- This should currently replace everything in Control.Applicative.
-  -- Ideally it would be its superclass.
+  infixl 4 <*
+  infixl 4 *>
 
-  infixl 4 <.
-  infixl 4 .>
+  (<*) :: forall a b f. (Apply f) => f a -> f b -> f a
+  (<*) a b = const <$> a <*> b
 
-  -- This should be a subclass of Functor.
-  class Apply f where
-    -- Until we get default implementations, use `<.>` as `<*>`
-    (<.>) :: forall a b. (Functor f) => f (a -> b) -> f a -> f b
+  (*>) :: forall a b f. (Apply f) => f a -> f b -> f b
+  (*>) a b = const id <$> a <*> b
 
-  (<.) :: forall a b f. (Apply f, Functor f) => f a -> f b -> f a
-  (<.) a b = const <$> a <.> b
+  lift2 :: forall a b c f. (Apply f) => (a -> b -> c) -> f a -> f b -> f c
+  lift2 f a b = f <$> a <*> b
 
-  (.>) :: forall a b f. (Apply f, Functor f) => f a -> f b -> f b
-  (.>) a b = const id <$> a <.> b
+  lift3 :: forall a b c d f. (Apply f) => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+  lift3 f a b c = f <$> a <*> b <*> c
 
-  lift2 :: forall a b c f. (Apply f, Functor f) => (a -> b -> c) -> f a -> f b -> f c
-  lift2 f a b = f <$> a <.> b
+  lift4 :: forall a b c d e f. (Apply f) => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
+  lift4 f a b c d = f <$> a <*> b <*> c <*> d
 
-  lift3 :: forall a b c d f. (Apply f, Functor f) => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
-  lift3 f a b c = f <$> a <.> b <.> c
+  lift5 :: forall a b c d e f g. (Apply f) => (a -> b -> c -> d -> e -> g) -> f a -> f b -> f c -> f d -> f e -> f g
+  lift5 f a b c d e = f <$> a <*> b <*> c <*> d <*> e
+
+  forever :: forall a b f. (Apply f) => f a -> f b
+  forever a = a *> forever a

src/Control/Apply.purs

@@ -1,34 +1,20 @@
 module Control.Bind where
 
-  -- This should replace most things in Control.Monad.
-  -- Ideally it would be its superclass.
+  infixr 1 =<<
+  infixr 1 >=>
+  infixr 1 <=<
 
-  infixl 1 >>-
+  (=<<) :: forall a b m. (Bind m) => (a -> m b) -> m a -> m b
+  (=<<) f m = m >>= f
 
-  import Control.Apply
+  (>=>) :: forall a b c m. (Bind m) => (a -> m b) -> (b -> m c) -> a -> m c
+  (>=>) f g a = f a >>= g
 
-  -- This should be a subclass of Apply
-  class Bind m where
-    -- We should be able to provide either one of these and derive the other.
-    (>>-) :: forall a b. (Apply m) => m a -> (a -> m b) -> m b
-    -- (>>-) m f = join (f <$> m)
-    join :: forall a. (Apply m) => m (m a) -> m a
-    -- join m = m >>- id
+  (<=<) :: forall a b c m. (Bind m) => (b -> m c) -> (a -> m b) -> a -> m c
+  (<=<) f g a = f =<< g a
 
-  instance applyFromBind :: (Bind m) => Apply m where
-    (<.>) f a = f >>- \f' -> f' <$> a
+  join :: forall a m. (Bind m) => m (m a) -> m a
+  join m = m >>= id
 
-  (-<<) :: forall a b m. (Apply m, Bind m) => (a -> m b) -> m a -> m b
-  (-<<) f m = m >>- f
-
-  (>->) :: forall a b c m. (Apply m, Bind m) => (a -> m b) -> (b -> m c) -> a -> m c
-  (>->) f g a = f a >>- g
-
-  (<-<) :: forall a b c m. (Apply m, Bind m) => (b -> m c) -> (a -> m b) -> a -> m c
-  (<-<) f g a = f -<< g a
-
-  ifM :: forall a m. (Apply m, Bind m) => m Boolean -> m a -> m a -> m a
-  ifM cond t f = cond >>- \cond' -> if cond' then t else f
-
-  forever :: forall a b m. (Apply m, Functor m, Bind m) => m a -> m b
-  forever a = a .> forever a
+  ifM :: forall a m. (Bind m) => m Boolean -> m a -> m a -> m a
+  ifM cond t f = cond >>= \cond' -> if cond' then t else f

src/Control/Bind.purs

@@ -1,35 +1,20 @@
 module Control.Monad where
 
-import Prelude
-import Data.Array
-
 replicateM :: forall m a. (Monad m) => Number -> m a -> m [a]
 replicateM 0 _ = return []
 replicateM n m = do
   a <- m
   as <- replicateM (n - 1) m
   return (a : as)
 
-infixr 1 >=>
-infixr 1 <=<
-
-(>=>) :: forall m a b c. (Monad m) => (a -> m b) -> (b -> m c) -> a -> m c
-(>=>) f g a = do
-  b <- f a
-  g b
-
-(<=<) :: forall m a b c. (Monad m) => (b -> m c) -> (a -> m b) -> a -> m c
-(<=<) = flip (>=>)
-
-join :: forall m a. (Monad m) => m (m a) -> m a
-join mm = do
-  m <- mm
-  m
-
 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
 
 when :: forall m. (Monad m) => Boolean -> m {} -> m {}
 when true m = m
 when false _ = return {}
+
+unless :: forall m. (Monad m) => Boolean -> m {} -> m {}
+unless false m = m
+unless true _ = return {}