Alternative & MonadPlus

README.md

@@ -1,5 +1,27 @@
 # Module Documentation
 
+## Module Control.Alt
+
+### Type Classes
+
+    class (Functor f) <= Alt f where
+      (<|>) :: forall a. f a -> f a -> f a
+
+
+## Module Control.Alternative
+
+### Type Classes
+
+    class (Applicative f, Plus f) <= Alternative f where
+
+
+### Values
+
+    many :: forall f a. (Alternative f, Lazy1 f) => f a -> f [a]
+
+    some :: forall f a. (Alternative f, Lazy1 f) => f a -> f [a]
+
+
 ## Module Control.Apply
 
 ### Values
@@ -34,6 +56,29 @@
     join :: forall a m. (Bind m) => m (m a) -> m a
 
 
+## Module Control.Lazy
+
+### Type Classes
+
+    class Lazy l where
+      defer :: (Unit -> l) -> l
+
+    class Lazy1 l where
+      defer1 :: forall a. (Unit -> l a) -> l a
+
+    class Lazy2 l where
+      defer2 :: forall a b. (Unit -> l a b) -> l a b
+
+
+### Values
+
+    fix :: forall l a. (Lazy l) => (l -> l) -> l
+
+    fix1 :: forall l a. (Lazy1 l) => (l a -> l a) -> l a
+
+    fix2 :: forall l a b. (Lazy2 l) => (l a b -> l a b) -> l a b
+
+
 ## Module Control.Monad
 
 ### Values
@@ -44,4 +89,24 @@
 
     unless :: forall m. (Monad m) => Boolean -> m Unit -> m Unit
 
-    when :: forall m. (Monad m) => Boolean -> m Unit -> m Unit
+    when :: forall m. (Monad m) => Boolean -> m Unit -> m Unit
+
+
+## Module Control.MonadPlus
+
+### Type Classes
+
+    class (Monad m, Alternative m) <= MonadPlus m where
+
+
+### Values
+
+    guard :: forall m. (MonadPlus m) => Boolean -> m Unit
+
+
+## Module Control.Plus
+
+### Type Classes
+
+    class (Alt f) <= Plus f where
+      empty :: forall a. f a

src/Control/Alt.purs

@@ -0,0 +1,6 @@
+module Control.Alt where
+
+infixl 3 <|>
+
+class (Functor f) <= Alt f where
+  (<|>) :: forall a. f a -> f a -> f a

src/Control/Alternative.purs

@@ -0,0 +1,14 @@
+module Control.Alternative where
+
+import Control.Alt
+import Control.Lazy
+import Control.Plus
+
+class (Applicative f, Plus f) <= Alternative f
+
+some :: forall f a. (Alternative f, Lazy1 f) => f a -> f [a]
+some v = (:) <$> v <*> defer1 (\_ -> many v)
+
+many :: forall f a. (Alternative f, Lazy1 f) => f a -> f [a]
+many v = some v <|> pure []
+

src/Control/Lazy.purs

@@ -0,0 +1,19 @@
+module Control.Lazy where
+
+class Lazy l where
+  defer :: (Unit -> l) -> l
+
+class Lazy1 l where
+  defer1 :: forall a. (Unit -> l a) -> l a
+
+class Lazy2 l where
+  defer2 :: forall a b. (Unit -> l a b) -> l a b
+
+fix :: forall l a. (Lazy l) => (l -> l) -> l
+fix f = defer (\_ -> f (fix f))
+
+fix1 :: forall l a. (Lazy1 l) => (l a -> l a) -> l a
+fix1 f = defer1 (\_ -> f (fix1 f))
+
+fix2 :: forall l a b. (Lazy2 l) => (l a b -> l a b) -> l a b
+fix2 f = defer2 (\_ -> f (fix2 f))

src/Control/MonadPlus.purs

@@ -0,0 +1,10 @@
+module Control.MonadPlus where
+
+import Control.Alternative
+import Control.Plus
+
+class (Monad m, Alternative m) <= MonadPlus m
+
+guard :: forall m. (MonadPlus m) => Boolean -> m Unit
+guard true = return unit
+guard false = empty

src/Control/Plus.purs

@@ -0,0 +1,6 @@
+module Control.Plus where
+
+import Control.Alt
+
+class (Alt f) <= Plus f where
+  empty :: forall a. f a