Merge pull request #16 from purescript-contrib/compiler/0.12

Compiler/0.12

Author: garyb

.gitignore

@@ -1,5 +1,7 @@
-.psci*
-bower_components/
-output/
-.psc-package
-.psc-ide-port
+/.*
+!/.gitignore
+!/.travis.yml
+package-lock.json
+/bower_components/
+/node_modules/
+/output/

.travis.yml

@@ -1,8 +1,14 @@
 language: node_js
 dist: trusty
 sudo: required
-node_js: 6
+node_js: stable
+env:
+  - PATH=$HOME/purescript:$PATH
 install:
+  - TAG=$(wget -q -O - https://github.com/purescript/purescript/releases/latest --server-response --max-redirect 0 2>&1 | sed -n -e 's/.*Location:.*tag\///p')
+  - wget -O $HOME/purescript.tar.gz https://github.com/purescript/purescript/releases/download/$TAG/linux64.tar.gz
+  - tar -xvf $HOME/purescript.tar.gz -C $HOME/
+  - chmod a+x $HOME/purescript
   - npm install -g bower
   - npm install
 script:

bower.json

@@ -14,7 +14,9 @@
     "url": "git://github.com/purescript-contrib/purescript-aff-coroutines.git"
   },
   "dependencies": {
-    "purescript-aff": "^4.0.0",
-    "purescript-coroutines": "^4.0.0"
+    "purescript-aff": "^5.0.0",
+    "purescript-avar": "^3.0.0",
+    "purescript-console": "^4.1.0",
+    "purescript-coroutines": "^5.0.0"
   }
 }

package.json

@@ -6,9 +6,8 @@
     "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^11.0.0",
-    "purescript-psa": "^0.5.0",
-    "purescript": "^0.11.0",
-    "rimraf": "^2.5.4"
+    "pulp": "^12.2.0",
+    "purescript-psa": "^0.6.0",
+    "rimraf": "^2.6.2"
   }
 }

src/Control/Coroutine/Aff.purs

@@ -1,44 +1,37 @@
--- | This module defines functions for creating coroutines on top of the `Aff` monad.
+-- | This module defines functions for creating coroutines on top of the `Aff`
+-- | monad.
 -- |
--- | The `Aff` monad only supports actions which return a single value, asynchronously, so this
--- | module provides a principled way to deal with asynchronous _streams_ of values, and asynchronous consumers
--- | of streamed data.
-
+-- | The `Aff` monad only supports actions which return a single value,
+-- | asynchronously, so this module provides a principled way to deal with
+-- | asynchronous _streams_ of values, and asynchronous consumers of streamed
+-- | data.
 module Control.Coroutine.Aff where
 
 import Prelude
 
 import Control.Coroutine (Producer, producer)
-import Control.Monad.Aff (Aff, runAff, forkAff)
-import Control.Monad.Aff.AVar (AVAR, makeEmptyVar, takeVar, putVar)
-import Control.Monad.Aff.Class (class MonadAff, liftAff)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Class (liftEff)
+import Effect.Aff (Aff, runAff, forkAff)
+import Effect.Aff.AVar as AVar
+import Effect.Aff.Class (class MonadAff, liftAff)
+import Effect (Effect)
+import Effect.Class (liftEffect)
 import Control.Monad.Free.Trans (hoistFreeT)
 import Control.Monad.Trans.Class (lift)
 import Data.Either (Either(..))
 import Data.Newtype (class Newtype)
 
-newtype Emitter m a r eff = Emitter (Step a r -> m (avar :: AVAR | eff) Unit)
+newtype Emitter m a r = Emitter (Step a r -> m Unit)
 
-derive instance newtypeEmitter :: Newtype (Emitter m a r eff) _
+derive instance newtypeEmitter :: Newtype (Emitter m a r) _
 
 data Step a b
   = Emit a
   | Finish b
 
-emit
-  :: forall m a r eff
-   . Emitter m a r eff
-  -> a
-  -> m (avar :: AVAR | eff) Unit
+emit :: forall m a r. Emitter m a r -> a -> m Unit
 emit (Emitter f) = f <<< Emit
 
-close
-  :: forall m a r eff
-   . Emitter m a r eff
-  -> r
-  -> m (avar :: AVAR | eff) Unit
+close :: forall m a r. Emitter m a r -> r -> m Unit
 close (Emitter f) = f <<< Finish
 
 -- | Create a `Producer` using an asynchronous callback.
@@ -56,20 +49,13 @@ close (Emitter f) = f <<< Finish
 -- |   log "Done!"
 -- |   close emitter "finished"
 -- | ```
-produce
-  :: forall a r eff
-   . (Emitter Eff a r eff -> Eff (avar :: AVAR | eff) Unit)
-  -> Producer a (Aff (avar :: AVAR | eff)) r
+produce :: forall a r. (Emitter Effect a r -> Effect Unit) -> Producer a Aff r
 produce recv = produceAff \(Emitter send) ->
-  liftEff (recv (Emitter (void <<< runAff (const (pure unit)) <<< send)))
+  liftEffect (recv (Emitter (void <<< runAff (const (pure unit)) <<< send)))
 
 -- | A version of `produce` that creates a `Producer` with an underlying
 -- | `MonadAff`, rather than `Aff` specifically.
-produce'
-  :: forall a r m eff
-   . MonadAff (avar :: AVAR | eff) m
-  => (Emitter Eff a r eff -> Eff (avar :: AVAR | eff) Unit)
-  -> Producer a m r
+produce' :: forall a r m. MonadAff m => (Emitter Effect a r -> Effect Unit) -> Producer a m r
 produce' = hoistFreeT liftAff <<< produce
 
 -- | A variant of `produce` where the setup and callback functions use the `Aff`
@@ -84,13 +70,10 @@ produce' = hoistFreeT liftAff <<< produce
 -- |   delay $ Milliseconds 1000
 -- |   close emitter "finished"
 -- | ```
-produceAff
-  :: forall a r eff
-   . (Emitter Aff a r eff -> Aff (avar :: AVAR | eff) Unit)
-  -> Producer a (Aff (avar :: AVAR | eff)) r
+produceAff :: forall a r. (Emitter Aff a r -> Aff Unit) -> Producer a Aff r
 produceAff recv = do
-  v <- lift makeEmptyVar
-  _ <- lift (forkAff (recv (Emitter (flip putVar v))))
-  producer $ takeVar v <#> case _ of
+  v <- lift AVar.empty
+  _ <- lift (forkAff (recv (Emitter (flip AVar.put v))))
+  producer $ AVar.take v <#> case _ of
     Emit a -> Left a
     Finish b -> Right b

test/Main.purs

@@ -4,16 +4,14 @@ import Prelude
 
 import Control.Coroutine (Consumer, Producer, runProcess, consumer, ($$))
 import Control.Coroutine.Aff (emit, close, produceAff)
-import Control.Monad.Aff (Aff, Milliseconds(..), delay, runAff)
-import Control.Monad.Aff.AVar (AVAR)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Class (liftEff)
-import Control.Monad.Eff.Console (CONSOLE, log, logShow)
-import Control.Monad.Eff.Exception (EXCEPTION)
+import Effect.Aff (Aff, Milliseconds(..), delay, runAff)
+import Effect (Effect)
+import Effect.Class (liftEffect)
+import Effect.Console (log, logShow)
 import Data.Either (either)
 import Data.Maybe (Maybe(..))
 
-p :: forall eff. Producer String (Aff (avar :: AVAR | eff)) String
+p :: Producer String Aff String
 p = produceAff \emitter -> do
   delay (Milliseconds 1000.0)
   emit emitter "Working..."
@@ -24,8 +22,8 @@ p = produceAff \emitter -> do
   delay (Milliseconds 1000.0)
   close emitter "Done!"
 
-c :: forall eff. Consumer String (Aff (console :: CONSOLE | eff)) String
-c = consumer \s -> liftEff (log s) $> Nothing
+c :: Consumer String Aff String
+c = consumer \s -> liftEffect (log s) $> Nothing
 
-main :: forall eff. Eff (console :: CONSOLE, avar :: AVAR, err :: EXCEPTION | eff) Unit
+main :: Effect Unit
 main = void $ runAff (either logShow log) $ runProcess (p $$ c)