Merge pull request #76 from jqyu/bump

Bumps dependencies for 2.0 release [WIP]

Author: garyb

bower.json

@@ -24,13 +24,26 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-arrays": "^1.0.0",
-    "purescript-distributive": "^1.0.0",
-    "purescript-lazy": "^1.0.0",
-    "purescript-tailrec": "^1.0.0",
-    "purescript-unfoldable": "^1.0.0"
+    "purescript-arrays": "^1.1.0",
+    "purescript-lazy": "^2.0.0",
+    "purescript-tailrec": "^2.0.0",
+    "purescript-unfoldable": "^1.1.0",
+    "purescript-distributive": "bump",
+    "purescript-tuples": "^3.0.0"
   },
   "devDependencies": {
-    "purescript-console": "^1.0.0"
+    "purescript-console": "^2.0.0"
+  },
+  "resolutions": {
+    "purescript-tuples": "^3.0.0",
+    "purescript-monoid": "^2.0.0",
+    "purescript-foldable-traversable": "^2.0.0",
+    "purescript-st": "^2.0.0",
+    "purescript-eff": "^2.0.0",
+    "purescript-control": "^2.0.0",
+    "purescript-bifunctors": "^2.0.0",
+    "purescript-invariant": "^2.0.0",
+    "purescript-maybe": "^2.0.0",
+    "purescript-prelude": "^2.1.0"
   }
 }

src/Control/Comonad/Env.purs

@@ -15,7 +15,8 @@ import Prelude
 import Control.Comonad.Env.Class (class ComonadEnv, ask, asks, local)
 import Control.Comonad.Env.Trans (EnvT(..), mapEnvT, runEnvT, withEnvT)
 
-import Data.Identity (Identity(..), runIdentity)
+import Data.Identity (Identity(..))
+import Data.Newtype (unwrap)
 import Data.Tuple (Tuple(..))
 
 -- | The `Env` comonad is a synonym for the `EnvT` comonad transformer, applied
@@ -24,7 +25,7 @@ type Env e = EnvT e Identity
 
 -- | Unwrap a value in the `Env` comonad.
 runEnv :: forall e a. Env e a -> Tuple e a
-runEnv (EnvT x) = runIdentity <$> x
+runEnv (EnvT x) = unwrap <$> x
 
 -- | Change the environment type in an `Env` computation.
 withEnv :: forall e1 e2 a. (e1 -> e2) -> Env e1 a -> Env e2 a

src/Control/Comonad/Env/Class.purs

@@ -20,7 +20,7 @@ import Data.Tuple (Tuple(..), fst)
 -- | - `ask (local f x) = f (ask x)`
 -- | - `extract (local _ x) = extract a`
 -- | - `extend g (local f x) = extend (g <<< local f) x`
-class Comonad w <= ComonadEnv e w where
+class Comonad w <= ComonadEnv e w | w -> e where
   ask :: forall a. w a -> e
   local :: forall a. (e -> e) -> w a -> w a
 

src/Control/Comonad/Store.purs

@@ -13,7 +13,8 @@ import Prelude
 import Control.Comonad.Store.Class (class ComonadStore, experiment, peek, peeks, pos, seek, seeks)
 import Control.Comonad.Store.Trans (StoreT(..), runStoreT)
 
-import Data.Identity (Identity(..), runIdentity)
+import Data.Identity (Identity(..))
+import Data.Newtype (unwrap)
 import Data.Tuple (Tuple(..), swap)
 
 -- | The `Store` comonad is a synonym for the `StoreT` comonad transformer, applied
@@ -22,7 +23,7 @@ type Store s a = StoreT s Identity a
 
 -- | Unwrap a value in the `Store` comonad.
 runStore :: forall s a. Store s a -> Tuple (s -> a) s
-runStore (StoreT s) = swap (runIdentity <$> swap s)
+runStore (StoreT s) = swap (unwrap <$> swap s)
 
 -- | Create a value in context in the `Store` comonad.
 store :: forall s a. (s -> a) -> s -> Store s a

src/Control/Comonad/Store/Class.purs

@@ -29,7 +29,7 @@ import Data.Tuple (Tuple(..))
 -- | blur :: forall w. (ComonadStore Number w) -> w Number -> w Number
 -- | blur = extend \r -> (peeks (\n -> n - 1) r + peeks (\n -> n + 1) r) / 2)
 -- | ```
-class Comonad w <= ComonadStore s w where
+class Comonad w <= ComonadStore s w | w -> s where
   pos :: forall a. w a -> s
   peek :: forall a. s -> w a -> a
 

src/Control/Comonad/Traced.purs

@@ -13,15 +13,16 @@ import Prelude
 import Control.Comonad.Traced.Class (class ComonadTraced, censor, listen, listens, track, tracks)
 import Control.Comonad.Traced.Trans (TracedT(..), runTracedT)
 
-import Data.Identity (Identity(..), runIdentity)
+import Data.Identity (Identity(..))
+import Data.Newtype (unwrap)
 
 -- | The `Traced` comonad is a synonym for the `TracedT` comonad transformer, applied
 -- | to the `Identity` monad.
 type Traced m = TracedT m Identity
 
 -- | Unwrap a value in the `Traced` comonad.
 runTraced :: forall m a. Traced m a -> m -> a
-runTraced (TracedT t) = runIdentity t
+runTraced (TracedT t) = unwrap t
 
 -- | Create a value in context in the `Traced` comonad.
 traced :: forall m a. (m -> a) -> Traced m a

src/Control/Comonad/Traced/Class.purs

@@ -28,7 +28,7 @@ import Data.Tuple (Tuple(..))
 -- | blur :: forall w. (ComonadTraced (Additive Number) w) -> w Number -> w Number
 -- | blur = extend \r -> (track (Additive (-1)) r + track (Additive 1) r) / 2
 -- | ```
-class Comonad w <= ComonadTraced t w where
+class Comonad w <= ComonadTraced t w | w -> t where
   track :: forall a. t -> w a -> a
 
 -- | Extracts a value at a relative position which depends on the current value.

src/Control/Monad/Cont.purs

@@ -13,24 +13,25 @@ import Prelude
 import Control.Monad.Cont.Class (class MonadCont, callCC)
 import Control.Monad.Cont.Trans (class MonadTrans, ContT(..), lift, mapContT, runContT, withContT)
 
-import Data.Identity (Identity(..), runIdentity)
+import Data.Identity (Identity(..))
+import Data.Newtype (unwrap)
 
 -- | The `Cont` monad is a synonym for the `ContT` monad transformer applied to
 -- | the `Identity` monad.
 type Cont r a = ContT r Identity a
 
 -- | Creates a computation in the `Cont` monad.
 cont :: forall a r. ((a -> r) -> r) -> Cont r a
-cont f = ContT (\c -> Identity (f (runIdentity <<< c)))
+cont f = ContT (\c -> Identity (f (unwrap <<< c)))
 
 -- | Runs a computation in the `Cont` monad.
 runCont :: forall r a. ContT r Identity a -> (a -> r) -> r
-runCont cc k = runIdentity (runContT cc (Identity <<< k))
+runCont cc k = unwrap (runContT cc (Identity <<< k))
 
 -- | Transform the result of a continuation-passing function.
 mapCont :: forall r a. (r -> r) -> Cont r a -> Cont r a
-mapCont f = mapContT (Identity <<< f <<< runIdentity)
+mapCont f = mapContT (Identity <<< f <<< unwrap)
 
 -- | Transform the continuation passed into the continuation-passing function.
 withCont :: forall a b r. ((b -> r) -> (a -> r)) -> Cont r a -> Cont r b
-withCont f = withContT (compose Identity <<< f <<< compose runIdentity)
+withCont f = withContT (compose Identity <<< f <<< compose unwrap)

src/Control/Monad/Error/Class.purs

@@ -23,7 +23,7 @@ import Data.Either (Either(..))
 -- | - Catch: `catchError (throwError e) f = f e`
 -- | - Pure: `catchError (pure a) f = pure a`
 -- |
-class Monad m <= MonadError e m where
+class Monad m <= MonadError e m | m -> e where
   throwError :: forall a. e -> m a
   catchError :: forall a. m a -> (e -> m a) -> m a
 

src/Control/Monad/Except.purs

@@ -14,7 +14,8 @@ import Control.Monad.Error.Class (class MonadError, catchError, catchJust, throw
 import Control.Monad.Except.Trans (class MonadTrans, ExceptT(..), except, lift, mapExceptT, runExceptT, withExceptT)
 
 import Data.Either (Either)
-import Data.Identity (Identity(..), runIdentity)
+import Data.Identity (Identity(..))
+import Data.Newtype (unwrap)
 
 -- | A parametrizable exception monad; computations are either exceptions or
 -- | pure values. If an exception is thrown (see `throwError`), the computation
@@ -35,11 +36,11 @@ type Except e a = ExceptT e Identity a
 
 -- | Run a computation in the `Except` monad. The inverse of `except`.
 runExcept :: forall e a. Except e a -> Either e a
-runExcept = runIdentity <<< runExceptT
+runExcept = unwrap <<< runExceptT
 
 -- | Transform the unwrapped computation using the given function.
 mapExcept :: forall e e' a b. (Either e a -> Either e' b) -> Except e a -> Except e' b
-mapExcept f = mapExceptT (Identity <<< f <<< runIdentity)
+mapExcept f = mapExceptT (Identity <<< f <<< unwrap)
 
 -- | Transform any exceptions thrown by an `Except` computation using the given function.
 withExcept :: forall e e' a. (e -> e') -> Except e a -> Except e' a

src/Control/Monad/Except/Trans.purs

@@ -14,7 +14,7 @@ import Control.Monad.Cont.Class (class MonadCont, callCC)
 import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Error.Class (class MonadError, throwError, catchError)
 import Control.Monad.Reader.Class (class MonadReader, local, ask)
-import Control.Monad.Rec.Class (class MonadRec, tailRecM)
+import Control.Monad.Rec.Class (class MonadRec, tailRecM, Step(..))
 import Control.Monad.RWS.Class (class MonadRWS)
 import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans (class MonadTrans, lift)
@@ -75,9 +75,9 @@ instance monadRecExceptT :: MonadRec m => MonadRec (ExceptT e m) where
     case f a of ExceptT m ->
       m >>= \m' ->
         pure case m' of
-          Left e -> Right (Left e)
-          Right (Left a1) -> Left a1
-          Right (Right b) -> Right (Right b)
+          Left e -> Done (Left e)
+          Right (Loop a1) -> Loop a1
+          Right (Done b) -> Done (Right b)
 
 instance altExceptT :: (Semigroup e, Monad m) => Alt (ExceptT e m) where
   alt (ExceptT m) (ExceptT n) = ExceptT do

src/Control/Monad/Maybe/Trans.purs

@@ -13,7 +13,7 @@ import Control.Monad.Cont.Class (class MonadCont, callCC)
 import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Error.Class (class MonadError, catchError, throwError)
 import Control.Monad.Reader.Class (class MonadReader, local, ask)
-import Control.Monad.Rec.Class (class MonadRec, tailRecM)
+import Control.Monad.Rec.Class (class MonadRec, tailRecM, Step(..))
 import Control.Monad.RWS.Class (class MonadRWS)
 import Control.Monad.State.Class (class MonadState, state)
 import Control.Monad.Trans (class MonadTrans, lift)
@@ -22,7 +22,6 @@ import Control.MonadPlus (class MonadPlus)
 import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus)
 
-import Data.Either (Either(..))
 import Data.Maybe (Maybe(..))
 import Data.Tuple (Tuple(..))
 
@@ -81,12 +80,12 @@ instance monadZeroMaybeT :: Monad m => MonadZero (MaybeT m)
 instance monadRecMaybeT :: MonadRec m => MonadRec (MaybeT m) where
   tailRecM f =
     MaybeT <<< tailRecM \a ->
-      case f a of
-        MaybeT m -> m >>= \m' ->
+      case f a of MaybeT m ->
+        m >>= \m' ->
           pure case m' of
-            Nothing -> Right Nothing
-            Just (Left a1) -> Left a1
-            Just (Right b) -> Right (Just b)
+            Nothing -> Done Nothing
+            Just (Loop a1) -> Loop a1
+            Just (Done b) -> Done (Just b)
 
 instance monadEffMaybe :: MonadEff eff m => MonadEff eff (MaybeT m) where
   liftEff = lift <<< liftEff

src/Control/Monad/RWS.purs

@@ -17,7 +17,8 @@ import Prelude
 import Control.Monad.RWS.Class (class MonadRWS, class MonadReader, class MonadState, class MonadTrans, class MonadWriter, ask, censor, get, gets, lift, listen, listens, local, modify, pass, put, reader, state, tell, writer)
 import Control.Monad.RWS.Trans (class MonadTrans, RWSResult(..), RWST(..), evalRWST, execRWST, lift, mapRWST, runRWST, withRWST)
 
-import Data.Identity (Identity(..), runIdentity)
+import Data.Identity (Identity(..))
+import Data.Newtype (unwrap)
 import Data.Tuple (Tuple)
 
 -- | The `RWS` monad is a synonym for the `RWST` monad transformer, applied
@@ -35,15 +36,15 @@ runRWS m r s = case m of RWST f -> case f r s of Identity x -> x
 
 -- | Run a computation in the `RWS` monad, discarding the final state
 evalRWS :: forall r w s a. RWS r w s a -> r -> s -> Tuple a w
-evalRWS m r s = runIdentity $ evalRWST m r s
+evalRWS m r s = unwrap $ evalRWST m r s
 
 -- | Run a computation in the `RWS` monad, discarding the result
 execRWS :: forall r w s a. RWS r w s a -> r -> s -> Tuple s w
-execRWS m r s = runIdentity $ execRWST m r s
+execRWS m r s = unwrap $ execRWST m r s
 
 -- | Change the types of the result and accumulator in a `RWS` action
 mapRWS :: forall r w1 w2 s a1 a2. (RWSResult s a1 w1 -> RWSResult s a2 w2) -> RWS r w1 s a1 -> RWS r w2 s a2
-mapRWS f = mapRWST (runIdentity >>> f >>> Identity)
+mapRWS f = mapRWST (unwrap >>> f >>> Identity)
 
 -- | Change the type of the context in a `RWS` action
 withRWS :: forall r1 r2 w s a. (r2 -> s -> Tuple r1 s) -> RWS r1 w s a -> RWS r2 w s a

src/Control/Monad/RWS/Class.purs

@@ -19,4 +19,4 @@ import Control.Monad.Writer.Class (class MonadWriter, censor, listen, listens, p
 -- |
 -- | An implementation is provided for `RWST`, and for other monad transformers
 -- | defined in this library.
-class (MonadReader r m, MonadWriter w m, MonadState s m) <= MonadRWS r w s m
+class (MonadReader r m, MonadWriter w m, MonadState s m) <= MonadRWS r w s m | m -> r w s

src/Control/Monad/RWS/Trans.purs

@@ -12,13 +12,12 @@ import Prelude
 import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Error.Class (class MonadError, throwError, catchError)
 import Control.Monad.Reader.Class (class MonadReader)
-import Control.Monad.Rec.Class (class MonadRec, tailRecM)
+import Control.Monad.Rec.Class (class MonadRec, tailRecM, Step(..))
 import Control.Monad.RWS.Class (class MonadRWS)
 import Control.Monad.State.Class (class MonadState)
 import Control.Monad.Trans (class MonadTrans, lift)
 import Control.Monad.Writer.Class (class MonadWriter)
 
-import Data.Either (Either(..))
 import Data.Monoid (class Monoid, mempty)
 import Data.Tuple (Tuple(..), uncurry)
 
@@ -111,5 +110,5 @@ instance monadRecRWST :: (MonadRec m, Monoid w) => MonadRec (RWST r w s m) where
         RWST m -> do
           RWSResult state' result' writer' <- m r state
           pure case result' of
-            Left a -> Left (RWSResult state' a (writer <> writer'))
-            Right b -> Right (RWSResult state' b (writer <> writer'))
+            Loop a -> Loop (RWSResult state' a (writer <> writer'))
+            Done b -> Done (RWSResult state' b (writer <> writer'))

src/Control/Monad/Reader.purs

@@ -14,20 +14,21 @@ import Prelude
 import Control.Monad.Reader.Class (class MonadReader, ask, local, reader)
 import Control.Monad.Reader.Trans (class MonadTrans, ReaderT(..), lift, mapReaderT, runReaderT, withReaderT)
 
-import Data.Identity (Identity(..), runIdentity)
+import Data.Identity (Identity(..))
+import Data.Newtype (unwrap)
 
 -- | The `Reader` monad is a synonym for the `ReaderT` monad transformer, applied
 -- | to the `Identity` monad.
 type Reader r = ReaderT r Identity
 
 -- | Run a computation in the `Reader` monad.
 runReader :: forall r a. Reader r a -> r -> a
-runReader (ReaderT m) = runIdentity <<< m
+runReader (ReaderT m) = unwrap <<< m
 
 -- | Change the type of the context in a `Reader` monad action.
 withReader :: forall r1 r2 a. (r2 -> r1) -> Reader r1 a -> Reader r2 a
 withReader = withReaderT
 
 -- | Change the type of the result in a `Reader` monad action.
 mapReader :: forall r a b. (a -> b) -> Reader r a -> Reader r b
-mapReader f = mapReaderT $ Identity <<< f <<< runIdentity
+mapReader f = mapReaderT $ Identity <<< f <<< unwrap

src/Control/Monad/Reader/Class.purs

@@ -19,7 +19,7 @@ import Prelude
 -- | - `local f ask = f <$> ask`
 -- | - `local _ (pure a) = pure a`
 -- | - `local f (do { a <- x ; y }) = do { a <- local f x ; local f y }`
-class Monad m <= MonadReader r m where
+class Monad m <= MonadReader r m | m -> r where
   ask :: m r
   local :: forall a. (r -> r) -> m a -> m a
 

src/Control/Monad/Reader/Trans.purs

@@ -23,7 +23,6 @@ import Control.MonadZero (class MonadZero)
 import Control.Plus (class Plus, empty)
 
 import Data.Distributive (class Distributive, distribute, collect)
-import Data.Either (Either(..), either)
 
 -- | The reader monad transformer.
 -- |
@@ -106,4 +105,4 @@ instance distributiveReaderT :: Distributive g => Distributive (ReaderT e g) whe
 instance monadRecReaderT :: MonadRec m => MonadRec (ReaderT r m) where
   tailRecM k a = ReaderT \r -> tailRecM (k' r) a
     where
-    k' r a = case k a of ReaderT f -> pure <<< either Left Right =<< f r
+    k' r a = case k a of ReaderT f -> pure =<< f r

src/Control/Monad/State.purs

@@ -16,7 +16,8 @@ import Prelude
 import Control.Monad.State.Class (class MonadState, get, gets, modify, put, state)
 import Control.Monad.State.Trans (class MonadTrans, StateT(..), evalStateT, execStateT, lift, mapStateT, runStateT, withStateT)
 
-import Data.Identity (Identity(..), runIdentity)
+import Data.Identity (Identity(..))
+import Data.Newtype (unwrap)
 import Data.Tuple (Tuple(Tuple))
 
 -- | The `State` monad is a synonym for the `StateT` monad transformer, applied
@@ -25,7 +26,7 @@ type State s = StateT s Identity
 
 -- | Run a computation in the `State` monad
 runState :: forall s a. State s a -> s -> Tuple a s
-runState (StateT s) = runIdentity <<< s
+runState (StateT s) = unwrap <<< s
 
 -- | Run a computation in the `State` monad, discarding the final state
 evalState :: forall s a. State s a -> s -> a
@@ -37,7 +38,7 @@ execState (StateT m) s = case m s of Identity (Tuple _ s) -> s
 
 -- | Change the type of the result in a `State` action
 mapState :: forall s a b. (Tuple a s -> Tuple b s) -> State s a -> State s b
-mapState f = mapStateT (Identity <<< f <<< runIdentity)
+mapState f = mapStateT (Identity <<< f <<< unwrap)
 
 -- | Modify the state in a `State` action
 withState :: forall s a. (s -> s) -> State s a -> State s a

src/Control/Monad/State/Class.purs

@@ -21,7 +21,7 @@ import Data.Tuple (Tuple(..))
 -- | - `do { put x ; get } = put x $> x`
 -- | - `do { s <- get ; put s } = pure unit`
 -- |
-class Monad m <= MonadState s m where
+class Monad m <= MonadState s m | m -> s where
   state :: forall a. (s -> (Tuple a s)) -> m a
 
 -- | Get the current state.