Delete unlawful MonadPlus instance

README.md

@@ -40,7 +40,7 @@ deleteBlankLines path = do
 
 This looks like ordinary, synchronous, imperative code, but actually operates asynchronously without any callbacks. Error handling is baked in so you only deal with it when you want to.
 
-The library contains instances for `Semigroup`, `Monoid`, `Apply`, `Applicative`, `Bind`, `Monad`, `Alt`, `Plus`, `MonadPlus`, `MonadEff`, and `MonadError`. These instances allow you to compose asynchronous code as easily as `Eff`, as well as interop with existing `Eff` code.
+The library contains instances for `Semigroup`, `Monoid`, `Apply`, `Applicative`, `Bind`, `Monad`, `Alt`, `Plus`, `MonadEff`, and `MonadError`. These instances allow you to compose asynchronous code as easily as `Eff`, as well as interop with existing `Eff` code.
 
 ## Escaping Callback Hell
 

src/Control/Monad/Aff.purs

@@ -29,7 +29,7 @@ import Control.Monad.Eff.Class (class MonadEff)
 import Control.Monad.Eff.Exception (Error, EXCEPTION, throwException, error)
 import Control.Monad.Error.Class (class MonadThrow, class MonadError, throwError)
 import Control.Monad.Rec.Class (class MonadRec, Step(..))
-import Control.MonadPlus (class MonadZero, class MonadPlus)
+import Control.MonadZero (class MonadZero)
 import Control.Parallel (class Parallel)
 import Control.Plus (class Plus, empty)
 
@@ -198,8 +198,6 @@ instance alternativeAff :: Alternative (Aff e)
 
 instance monadZero :: MonadZero (Aff e)
 
-instance monadPlusAff :: MonadPlus (Aff e)
-
 instance monadRecAff :: MonadRec (Aff e) where
   tailRecM f a = runFn3 _tailRecM isLoop f a
     where

test/Test/Main.purs

@@ -241,6 +241,18 @@ test_syncTailRecM = do
     pure (Done 0)
   go { n, v } = pure (Loop { n: n - 1, v })
 
+test_monadPlusBad :: TestAVar Unit
+test_monadPlusBad = do
+  let f true  = throwError (error "error")
+      f false = pure unit
+  either (const $ log "Success: f throws regardless")
+         (const $ log "Failure: f does not throw")
+    =<< attempt ((pure true <|> pure false) >>= f)
+  either (const $ log "Failure: f exception not caught")
+         (const $ log "Success: f exception is caught")
+    =<< attempt ((pure true >>= f) <|> (pure false >>= f))
+  pure unit
+
 loopAndBounce :: forall eff. Int -> Aff (console :: CONSOLE | eff) Unit
 loopAndBounce n = do
   res <- tailRecM go n
@@ -338,6 +350,9 @@ main = do
     log "Testing synchronous tailRecM"
     test_syncTailRecM
 
+    log "Testing that MonadPlus instance would not be lawful"
+    test_monadPlusBad
+
     log "pre-delay"
     delay (Milliseconds 1000.0)
     log "post-delay"