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