Updates for 0.12

Author: garyb

bower.json

@@ -24,12 +24,12 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-arrays": "^4.0.0",
-    "purescript-lazy": "^3.0.0",
-    "purescript-distributive": "^3.0.0",
-    "purescript-tuples": "^4.0.0"
+    "purescript-arrays": "#compiler/0.12",
+    "purescript-lazy": "#compiler/0.12",
+    "purescript-distributive": "#compiler/0.12",
+    "purescript-tuples": "#compiler/0.12"
   },
   "devDependencies": {
-    "purescript-console": "^3.0.0"
+    "purescript-console": "#compiler/0.12"
   }
 }

src/Control/Comonad/Store/Class.purs

@@ -10,9 +10,7 @@ import Control.Comonad.Store.Trans (StoreT(..))
 import Control.Comonad.Traced.Trans (TracedT)
 import Control.Comonad.Trans.Class (lower)
 import Control.Extend (duplicate)
-
 import Data.Tuple (Tuple(..))
-import Data.Monoid (class Monoid)
 
 -- | The `ComonadStore` type class represents those monads which support local position information via
 -- | `pos` and `peek`.

src/Control/Comonad/Traced/Class.purs

@@ -6,8 +6,6 @@ import Prelude
 
 import Control.Comonad (class Comonad, extract)
 import Control.Comonad.Traced.Trans (TracedT(..))
-
-import Data.Monoid (class Monoid)
 import Data.Tuple (Tuple(..))
 
 -- | The `ComonadTraced` type class represents those monads which support relative (monoidal)

src/Control/Comonad/Traced/Trans.purs

@@ -7,8 +7,6 @@ import Prelude
 import Control.Comonad (class Comonad, extract)
 import Control.Comonad.Trans.Class (class ComonadTrans)
 import Control.Extend (class Extend, (<<=))
-
-import Data.Monoid (class Monoid, mempty)
 import Data.Newtype (class Newtype)
 
 -- | The cowriter comonad transformer.

src/Control/Monad/Cont/Trans.purs

@@ -9,12 +9,11 @@ module Control.Monad.Cont.Trans
 import Prelude
 
 import Control.Monad.Cont.Class (class MonadCont, callCC)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local)
 import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans.Class (class MonadTrans, lift)
-
 import Data.Newtype (class Newtype)
+import Effect.Class (class MonadEffect, liftEffect)
 
 -- | The CPS monad transformer.
 -- |
@@ -55,8 +54,8 @@ instance monadContT :: Monad m => Monad (ContT r m)
 instance monadTransContT :: MonadTrans (ContT r) where
   lift m = ContT (\k -> m >>= k)
 
-instance monadEffContT :: MonadEff eff m => MonadEff eff (ContT r m) where
-  liftEff = lift <<< liftEff
+instance monadEffectContT :: MonadEffect m => MonadEffect (ContT r m) where
+  liftEffect = lift <<< liftEffect
 
 instance monadAskContT :: MonadAsk r1 m => MonadAsk r1 (ContT r m) where
   ask = lift ask

src/Control/Monad/Except/Trans.purs

@@ -11,7 +11,6 @@ import Prelude
 import Control.Alt (class Alt)
 import Control.Alternative (class Alternative)
 import Control.Monad.Cont.Class (class MonadCont, callCC)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Error.Class (class MonadThrow, class MonadError, throwError, catchError)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local)
 import Control.Monad.Rec.Class (class MonadRec, tailRecM, Step(..))
@@ -21,11 +20,10 @@ import Control.Monad.Writer.Class (class MonadWriter, class MonadTell, pass, lis
 import Control.MonadPlus (class MonadPlus)
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
-
 import Data.Either (Either(..), either)
-import Data.Monoid (class Monoid, mempty)
 import Data.Newtype (class Newtype)
 import Data.Tuple (Tuple(..))
+import Effect.Class (class MonadEffect, liftEffect)
 
 -- | A monad transformer which adds exceptions to other monads, in the same way
 -- | as `Except`. As before, `e` is the type of exceptions, and `a` is the type
@@ -103,8 +101,8 @@ instance monadTransExceptT :: MonadTrans (ExceptT e) where
     a <- m
     pure $ Right a
 
-instance monadEffExceptT :: MonadEff eff m => MonadEff eff (ExceptT e m) where
-  liftEff = lift <<< liftEff
+instance monadEffectExceptT :: MonadEffect m => MonadEffect (ExceptT e m) where
+  liftEffect = lift <<< liftEffect
 
 instance monadContExceptT :: MonadCont m => MonadCont (ExceptT e m) where
   callCC f = ExceptT $ callCC \c ->
@@ -136,5 +134,5 @@ instance monadWriterExceptT :: MonadWriter w m => MonadWriter w (ExceptT e m) wh
   pass = mapExceptT \m -> pass do
     a <- m
     pure case a of
-      Left e -> Tuple (Left e) id
+      Left e -> Tuple (Left e) identity
       Right (Tuple r f) -> Tuple (Right r) f

src/Control/Monad/List/Trans.purs

@@ -40,19 +40,17 @@ import Prelude
 
 import Control.Alt (class Alt)
 import Control.Alternative (class Alternative)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
+import Control.Monad.Rec.Class as MR
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.MonadPlus (class MonadPlus)
-import Control.Monad.Rec.Class as MR
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
-
 import Data.Lazy (Lazy, defer, force)
 import Data.Maybe (Maybe(..), fromMaybe)
-import Data.Monoid (class Monoid)
 import Data.Newtype (class Newtype)
 import Data.Tuple (Tuple(..), fst, snd)
 import Data.Unfoldable (class Unfoldable)
+import Effect.Class (class MonadEffect, liftEffect)
 
 -- | The list monad transformer.
 -- |
@@ -139,7 +137,7 @@ iterate f a = unfold g a
 
 -- | Generate an infinite list by repeating a value.
 repeat :: forall f a. Monad f => a -> ListT f a
-repeat = iterate id
+repeat = iterate identity
 
 -- | Take a number of elements from the front of a list.
 take :: forall f a. Applicative f => Int -> ListT f a -> ListT f a
@@ -187,7 +185,7 @@ mapMaybe f = stepMap g where
 
 -- | Remove elements from a list which do not contain a value.
 catMaybes :: forall f a. Functor f => ListT f (Maybe a) -> ListT f a
-catMaybes = mapMaybe id
+catMaybes = mapMaybe identity
 
 -- | Perform the first step of a computation in the `ListT` monad.
 uncons :: forall f a. Monad f => ListT f a -> f (Maybe (Tuple a (ListT f a)))
@@ -318,5 +316,5 @@ instance monadZeroListT :: Monad f => MonadZero (ListT f)
 
 instance monadPlusListT :: Monad f => MonadPlus (ListT f)
 
-instance monadEffListT :: MonadEff eff m => MonadEff eff (ListT m) where
-  liftEff = lift <<< liftEff
+instance monadEffectListT :: MonadEffect m => MonadEffect (ListT m) where
+  liftEffect = lift <<< liftEffect

src/Control/Monad/Maybe/Trans.purs

@@ -10,7 +10,6 @@ import Prelude
 import Control.Alt (class Alt)
 import Control.Alternative (class Alternative)
 import Control.Monad.Cont.Class (class MonadCont, callCC)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Error.Class (class MonadThrow, class MonadError, catchError, throwError)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, ask, local)
 import Control.Monad.Rec.Class (class MonadRec, tailRecM, Step(..))
@@ -20,10 +19,10 @@ import Control.Monad.Writer.Class (class MonadWriter, class MonadTell, pass, lis
 import Control.MonadPlus (class MonadPlus)
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
-
 import Data.Maybe (Maybe(..))
 import Data.Newtype (class Newtype)
 import Data.Tuple (Tuple(..))
+import Effect.Class (class MonadEffect, liftEffect)
 
 -- | The `MaybeT` monad transformer.
 -- |
@@ -87,8 +86,8 @@ instance monadRecMaybeT :: MonadRec m => MonadRec (MaybeT m) where
             Just (Loop a1) -> Loop a1
             Just (Done b) -> Done (Just b)
 
-instance monadEffMaybe :: MonadEff eff m => MonadEff eff (MaybeT m) where
-  liftEff = lift <<< liftEff
+instance monadEffectMaybe :: MonadEffect m => MonadEffect (MaybeT m) where
+  liftEffect = lift <<< liftEffect
 
 instance monadContMaybeT :: MonadCont m => MonadCont (MaybeT m) where
   callCC f =
@@ -120,5 +119,5 @@ instance monadWriterMaybeT :: MonadWriter w m => MonadWriter w (MaybeT m) where
   pass = mapMaybeT \m -> pass do
     a <- m
     pure case a of
-      Nothing -> Tuple Nothing id
+      Nothing -> Tuple Nothing identity
       Just (Tuple v f) -> Tuple (Just v) f

src/Control/Monad/RWS/Trans.purs

@@ -11,18 +11,16 @@ import Prelude
 import Control.Alt (class Alt, (<|>))
 import Control.Alternative (class Alternative)
 import Control.Lazy (class Lazy)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Error.Class (class MonadThrow, class MonadError, throwError, catchError)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader)
 import Control.Monad.Rec.Class (class MonadRec, tailRecM, Step(..))
 import Control.Monad.State.Class (class MonadState)
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.Monad.Writer.Class (class MonadWriter, class MonadTell)
 import Control.Plus (class Plus, empty)
-
-import Data.Monoid (class Monoid, mempty)
 import Data.Newtype (class Newtype)
 import Data.Tuple (Tuple(..), uncurry)
+import Effect.Class (class MonadEffect, liftEffect)
 
 data RWSResult state result writer = RWSResult state result writer
 
@@ -85,8 +83,8 @@ instance monadTransRWST :: Monoid w => MonadTrans (RWST r w s) where
 instance lazyRWST :: Lazy (RWST r w s m a) where
   defer f = RWST \r s -> case f unit of RWST f' -> f' r s
 
-instance monadEffRWS :: (Monoid w, MonadEff eff m) => MonadEff eff (RWST r w s m) where
-  liftEff = lift <<< liftEff
+instance monadEffectRWS :: (Monoid w, MonadEffect m) => MonadEffect (RWST r w s m) where
+  liftEffect = lift <<< liftEffect
 
 instance monadAskRWST :: (Monad m, Monoid w) => MonadAsk r (RWST r w s m) where
   ask = RWST \r s -> pure $ RWSResult s r mempty

src/Control/Monad/Reader/Class.purs

@@ -17,7 +17,7 @@ class Monad m <= MonadAsk r m | m -> r where
   ask :: m r
 
 instance monadAskFun :: MonadAsk r ((->) r) where
-  ask = id
+  ask = identity
 
 -- | Projects a value from the global context in a `MonadAsk`.
 asks :: forall r m a. MonadAsk r m => (r -> a) -> m a