Drop MonadZero (#141)

* Drop MonadZero

* Drop udw censoring

* Added changelog entry

Author: JordanMartinez

CHANGELOG.md

@@ -6,6 +6,7 @@ Notable changes to this project are documented in this file. The format is based
 
 Breaking changes:
 - Update project and deps to PureScript v0.15.0 (#142 by @JordanMartinez)
+- Drop deprecated `MonadZero` instance (#141 by @JordanMartinez)
 
 New features:
 - Add `Foldable`, `FoldableWithIndex`, and `Traversable` instances for `EnvT` (#113 by @abaco)

package.json

@@ -2,7 +2,7 @@
   "private": true,
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "pulp build -- --censor-lib --strict --censor-codes='UserDefinedWarning'",
+    "build": "pulp build -- --censor-lib --strict",
     "test": "pulp test"
   },
   "devDependencies": {

src/Control/Monad/Except/Trans.purs

@@ -19,7 +19,6 @@ import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.Monad.Writer.Class (class MonadWriter, class MonadTell, pass, listen, tell)
 import Control.MonadPlus (class MonadPlus)
-import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
 import Data.Either (Either(..), either)
 import Data.Newtype (class Newtype)
@@ -95,8 +94,6 @@ instance alternativeExceptT :: (Monoid e, Monad m) => Alternative (ExceptT e m)
 
 instance monadPlusExceptT :: (Monoid e, Monad m) => MonadPlus (ExceptT e m)
 
-instance monadZeroExceptT :: (Monoid e, Monad m) => MonadZero (ExceptT e m)
-
 instance monadTransExceptT :: MonadTrans (ExceptT e) where
   lift m = ExceptT do
     a <- m

src/Control/Monad/Identity/Trans.purs

@@ -12,7 +12,6 @@ import Control.Monad.State.Class (class MonadState)
 import Control.Monad.Trans.Class (class MonadTrans)
 import Control.Monad.Writer.Class (class MonadTell, class MonadWriter)
 import Control.MonadPlus (class MonadPlus)
-import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
 import Data.Eq (class Eq1)
 import Data.Foldable (class Foldable)
@@ -52,7 +51,6 @@ derive newtype instance alternativeIdentityT :: Alternative m => Alternative (Id
 derive newtype instance bindIdentityT :: Bind m => Bind (IdentityT m)
 derive newtype instance monadIdentityT :: Monad m => Monad (IdentityT m)
 derive newtype instance monadRecIdentityT :: MonadRec m => MonadRec (IdentityT m)
-derive newtype instance monadZeroIdentityT :: MonadZero m => MonadZero (IdentityT m)
 derive newtype instance monadPlusIdentityT :: MonadPlus m => MonadPlus (IdentityT m)
 
 instance monadTransIdentityT :: MonadTrans IdentityT where

src/Control/Monad/List/Trans.purs

@@ -43,7 +43,6 @@ import Control.Alternative (class Alternative)
 import Control.Monad.Rec.Class as MR
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.MonadPlus (class MonadPlus)
-import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
 import Data.Lazy (Lazy, defer, force)
 import Data.Maybe (Maybe(..), fromMaybe)
@@ -322,8 +321,6 @@ instance plusListT :: Monad f => Plus (ListT f) where
 
 instance alternativeListT :: Monad f => Alternative (ListT f)
 
-instance monadZeroListT :: Monad f => MonadZero (ListT f)
-
 instance monadPlusListT :: Monad f => MonadPlus (ListT f)
 
 instance monadEffectListT :: MonadEffect m => MonadEffect (ListT m) where

src/Control/Monad/Maybe/Trans.purs

@@ -18,7 +18,6 @@ import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.Monad.Writer.Class (class MonadWriter, class MonadTell, pass, listen, tell)
 import Control.MonadPlus (class MonadPlus)
-import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
 import Data.Maybe (Maybe(..))
 import Data.Newtype (class Newtype)
@@ -75,8 +74,6 @@ instance alternativeMaybeT :: Monad m => Alternative (MaybeT m)
 
 instance monadPlusMaybeT :: Monad m => MonadPlus (MaybeT m)
 
-instance monadZeroMaybeT :: Monad m => MonadZero (MaybeT m)
-
 instance monadRecMaybeT :: MonadRec m => MonadRec (MaybeT m) where
   tailRecM f =
     MaybeT <<< tailRecM \a ->

src/Control/Monad/Reader/Trans.purs

@@ -19,7 +19,6 @@ import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.Monad.Writer.Class (class MonadWriter, class MonadTell, pass, listen, tell)
 import Control.MonadPlus (class MonadPlus)
-import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus, empty)
 import Data.Distributive (class Distributive, distribute, collect)
 import Data.Newtype (class Newtype)
@@ -71,8 +70,6 @@ instance bindReaderT :: Bind m => Bind (ReaderT r m) where
 
 instance monadReaderT :: Monad m => Monad (ReaderT r m)
 
-instance monadZeroReaderT :: MonadZero m => MonadZero (ReaderT r m)
-
 instance semigroupReaderT :: (Apply m, Semigroup a) => Semigroup (ReaderT s m a) where
   append = lift2 (<>)
 

src/Control/Monad/State/Trans.purs

@@ -20,7 +20,6 @@ import Control.Monad.State.Class (class MonadState, get, gets, modify, modify_,
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.Monad.Writer.Class (class MonadWriter, class MonadTell, pass, listen, tell)
 import Control.MonadPlus (class MonadPlus)
-import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus, empty)
 import Data.Newtype (class Newtype)
 import Data.Tuple (Tuple(..), fst, snd)
@@ -89,8 +88,6 @@ instance monadRecStateT :: MonadRec m => MonadRec (StateT s m) where
             Loop x -> Loop (Tuple x s1)
             Done y -> Done (Tuple y s1)
 
-instance monadZeroStateT :: MonadZero m => MonadZero (StateT s m)
-
 instance monadPlusStateT :: MonadPlus m => MonadPlus (StateT s m)
 
 instance monadTransStateT :: MonadTrans (StateT s) where

src/Control/Monad/Writer/Trans.purs

@@ -19,7 +19,6 @@ import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.Monad.Writer.Class (class MonadTell, tell, class MonadWriter, censor, listen, listens, pass)
 import Control.MonadPlus (class MonadPlus)
-import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus, empty)
 import Data.Newtype (class Newtype)
 import Data.Tuple (Tuple(..), snd)
@@ -85,8 +84,6 @@ instance monadRecWriterT :: (Monoid w, MonadRec m) => MonadRec (WriterT w m) whe
             Loop x -> Loop (Tuple x (w <> w1))
             Done y -> Done (Tuple y (w <> w1))
 
-instance monadZeroWriterT :: (Monoid w, MonadZero m) => MonadZero (WriterT w m)
-
 instance monadPlusWriterT :: (Monoid w, MonadPlus m) => MonadPlus (WriterT w m)
 
 instance monadTransWriterT :: Monoid w => MonadTrans (WriterT w) where