Update for PureScript 0.11

Author: garyb

.travis.yml

@@ -1,7 +1,7 @@
 language: node_js
 dist: trusty
 sudo: required
-node_js: 6
+node_js: stable
 env:
   - PATH=$HOME/purescript:$PATH
 install:

bower.json

@@ -24,13 +24,13 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-catenable-lists": "^3.0.0",
-    "purescript-exists": "^2.0.0",
-    "purescript-inject": "^3.0.0",
-    "purescript-transformers": "^2.0.0",
-    "purescript-unsafe-coerce": "^2.0.0"
+    "purescript-catenable-lists": "^4.0.0",
+    "purescript-exists": "^3.0.0",
+    "purescript-transformers": "^3.0.0",
+    "purescript-unsafe-coerce": "^3.0.0"
   },
   "devDependencies": {
-    "purescript-console": "^2.0.0"
+    "purescript-console": "^3.0.0",
+    "purescript-functors": "^2.0.0"
   }
 }

package.json

@@ -2,12 +2,12 @@
   "private": true,
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "pulp build --censor-lib --strict",
+    "build": "pulp build -- --censor-lib --strict",
     "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^9.0.1",
-    "purescript-psa": "^0.3.9",
-    "rimraf": "^2.5.0"
+    "pulp": "^10.0.4",
+    "purescript-psa": "^0.5.0-rc.1",
+    "rimraf": "^2.6.1"
   }
 }

src/Control/Comonad/Cofree.purs

@@ -73,7 +73,8 @@ unfoldCofree s e n =
 -- | functor underlying the cofree comonad.
 explore
   :: forall f g a b
-   . (Functor f, Functor g)
+   . Functor f
+  => Functor g
   => (forall x y. f (x -> y) -> g x -> y)
   -> Free f (a -> b)
   -> Cofree g a
@@ -87,7 +88,9 @@ explore pair m w =
 
 exploreM
   :: forall f g a b m
-   . (Functor f, Functor g, MonadRec m)
+   . Functor f
+  => Functor g
+  => MonadRec m
   => (forall x y. f (x -> y) -> g x -> m y)
   -> Free f (a -> b)
   -> Cofree g a

src/Control/Monad/Free.purs

@@ -2,9 +2,7 @@ module Control.Monad.Free
   ( Free
   , suspendF
   , liftF
-  , liftFI
   , hoistFree
-  , injF
   , foldFree
   , substFree
   , runFree
@@ -20,7 +18,6 @@ import Control.Monad.Trans.Class (class MonadTrans)
 import Data.CatList (CatList, empty, snoc, uncons)
 import Data.Either (Either(..))
 import Data.Foldable (class Foldable, foldMap, foldl, foldr)
-import Data.Inject (class Inject, inj)
 import Data.Maybe (Maybe(..))
 import Data.Traversable (class Traversable, traverse)
 import Data.Tuple (Tuple(..))
@@ -108,11 +105,6 @@ liftF f = fromView (Bind (unsafeCoerceF f) (pure <<< unsafeCoerceVal))
   unsafeCoerceVal :: forall a. Val -> a
   unsafeCoerceVal = unsafeCoerce
 
--- | Lift an action described by the generating type constructor `f` into
--- | `Free g` using `Inject` to go from `f` to `g`.
-liftFI :: forall f g. Inject f g => f ~> Free g
-liftFI fa = liftF (inj fa)
-
 -- | Suspend a value given the applicative functor `f` into the free monad.
 suspendF :: forall f. Applicative f => Free f ~> Free f
 suspendF f = fromView (Bind (unsafeCoerceF (pure f)) unsafeCoerceVal)
@@ -128,15 +120,6 @@ suspendF f = fromView (Bind (unsafeCoerceF (pure f)) unsafeCoerceVal)
 hoistFree :: forall f g. (f ~> g) -> Free f ~> Free g
 hoistFree k = substFree (liftF <<< k)
 
--- | Embed computations in one `Free` monad as computations in the `Free` monad
--- | for a coproduct type constructor.
--- |
--- | This construction allows us to write computations which are polymorphic in
--- | the particular `Free` monad we use, allowing us to extend the functionality
--- | of our monad later.
-injF :: forall f g. Inject f g => Free f ~> Free g
-injF = hoistFree inj
-
 -- | Run a free monad with a natural transformation from the type constructor `f`
 -- | to the tail-recursive monad `m`. See the `MonadRec` type class for more
 -- | details.
@@ -172,7 +155,8 @@ runFree k = go
 -- | monad `m`. See the `MonadRec` type class for more details.
 runFreeM
   :: forall f m a
-   . (Functor f, MonadRec m)
+   . Functor f
+  => MonadRec m
   => (f (Free f a) -> m (Free f a))
   -> Free f a
   -> m a

test/Test/Control/Monad/Free/Coproduct.purs

@@ -2,17 +2,11 @@ module Test.Control.Monad.Free.Coproduct where
 
 import Prelude
 
-import Control.Alt ((<|>))
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE, log)
-import Control.Monad.Free (Free, liftF, foldFree, injF)
+import Control.Monad.Free (Free, liftF, hoistFree, foldFree)
 
-import Data.Functor.Coproduct (Coproduct)
-import Data.Inject (prj)
-import Data.Maybe (fromJust)
-import Data.NaturalTransformation (NaturalTransformation)
-
-import Partial.Unsafe (unsafePartial)
+import Data.Functor.Coproduct (Coproduct, coproduct, left, right)
 
 data Teletype1F a = Print1 String a
 
@@ -40,33 +34,30 @@ type TF = Coproduct Teletype1F (Coproduct Teletype2F Teletype3F)
 type T a = Free TF a
 
 r :: T Unit
-r = injF (print1 "1")
+r = hoistFree left (print1 "1")
 
 s :: T Unit
-s = injF (print2 "2")
+s = hoistFree (right <<< left) (print2 "2")
 
 t :: T Unit
-t = injF (print3 "3")
+t = hoistFree (right <<< right) (print3 "3")
 
 u :: T Unit
 u =  r *> s *> t
 
-teletype1N :: forall eff. NaturalTransformation Teletype1F (Eff (console :: CONSOLE | eff))
+teletype1N :: forall eff. Teletype1F ~> Eff (console :: CONSOLE | eff)
 teletype1N (Print1 x a) = const a <$> log ("teletype1: " <> x)
 
-teletype2N :: forall eff. NaturalTransformation Teletype2F (Eff (console :: CONSOLE | eff))
+teletype2N :: forall eff. Teletype2F ~> Eff (console :: CONSOLE | eff)
 teletype2N (Print2 x a) = const a <$> log ("teletype2: " <> x)
 
-teletype3N :: forall eff. NaturalTransformation Teletype3F (Eff (console :: CONSOLE | eff))
+teletype3N :: forall eff. Teletype3F ~> Eff (console :: CONSOLE | eff)
 teletype3N (Print3 x a) = const a <$> log ("teletype3: " <> x)
 
-tN :: forall eff. NaturalTransformation TF (Eff (console :: CONSOLE | eff))
-tN fa = unsafePartial $
-  fromJust $ (teletype1N <$> prj fa) <|>
-             (teletype2N <$> prj fa) <|>
-             (teletype3N <$> prj fa)
+tN :: forall eff. TF ~> Eff (console :: CONSOLE | eff)
+tN = coproduct teletype1N $ coproduct teletype2N teletype3N
 
-run :: forall eff. NaturalTransformation T (Eff (console :: CONSOLE | eff))
+run :: forall eff. T ~> Eff (console :: CONSOLE | eff)
 run = foldFree tN
 
 main :: forall eff. Eff (console :: CONSOLE | eff) Unit