Updated for changes in prelude.

.gitignore

@@ -2,3 +2,4 @@
 /externs/
 /node_modules/
 /bower_components/
+/output/

src/Control/Apply.purs

@@ -0,0 +1,25 @@
+module Control.Apply where
+
+  infixl 4 <*
+  infixl 4 *>
+
+  (<*) :: forall a b f. (Apply f) => f a -> f b -> f a
+  (<*) a b = const <$> a <*> b
+
+  (*>) :: forall a b f. (Apply f) => f a -> f b -> f b
+  (*>) a b = const id <$> 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
+
+  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
+
+  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
+
+  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/Bind.purs

@@ -0,0 +1,20 @@
+module Control.Bind where
+
+  infixr 1 =<<
+  infixr 1 >=>
+  infixr 1 <=<
+
+  (=<<) :: forall a b m. (Bind m) => (a -> m b) -> m a -> m b
+  (=<<) f m = m >>= f
+
+  (>=>) :: forall a b c m. (Bind m) => (a -> m b) -> (b -> m c) -> a -> m c
+  (>=>) f g a = f a >>= g
+
+  (<=<) :: forall a b c m. (Bind m) => (b -> m c) -> (a -> m b) -> a -> m c
+  (<=<) f g a = f =<< g a
+
+  join :: forall a m. (Bind m) => m (m a) -> m a
+  join m = m >>= id
+
+  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/Monad.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 {}