Merge pull request #1 from cryogenian/compiler/0.12

0.12 updates

Author: kritzcreek

bower.json

@@ -8,18 +8,17 @@
     "example"
   ],
   "dependencies": {
-    "purescript-prelude": "^3.1.1",
-    "purescript-console": "^3.0.0",
-    "purescript-optlicative": "https://github.com/Thimoteus/purescript-optlicative.git#^4.0.2",
-    "purescript-mote": "^0.1.0",
-    "purescript-validation": "^3.2.0",
-    "purescript-node-process": "^5.0.0",
-    "purescript-eff": "^3.2.0",
-    "purescript-record": "^0.2.6"
+    "purescript-prelude": "^4.0.0",
+    "purescript-console": "^4.1.0",
+    "purescript-optlicative": "^5.0.0",
+    "purescript-validation": "^4.0.0",
+    "purescript-node-process": "^6.0.0",
+    "purescript-record": "^1.0.0",
+    "purescript-mote": "cryogenian/purescript-mote#compiler/0.12"
   },
   "devDependencies": {
-    "purescript-psci-support": "^3.0.0",
-    "purescript-test-unit": "^13.0.0",
-    "purescript-node-fs-aff": "^5.0.0"
+    "purescript-psci-support": "^4.0.0",
+    "purescript-test-unit": "^14.0.0",
+    "purescript-node-fs-aff": "^6.0.0"
   }
 }

example/Main.purs

@@ -2,8 +2,8 @@ module Main where
 
 import Prelude
 
-import Control.Monad.Aff (Aff, launchAff_)
-import Control.Monad.Eff (Eff)
+import Effect.Aff (Aff, launchAff_)
+import Effect (Effect)
 import Control.Monad.Trans.Class (lift)
 import Data.String as String
 import Data.Traversable (for_, sequence_)
@@ -21,9 +21,7 @@ import Test.Unit.Output.Fancy as Fancy
 theCommutativeProperty ∷ Int → Int → Result
 theCommutativeProperty a b = (a + b) === (b + a)
 
-suite
-  ∷ ∀ bracket eff eff1
-  . MoteT bracket (Test eff) (Aff (fs ∷ FS.FS | eff1)) Unit
+suite ∷ ∀ bracket. MoteT bracket Test Aff Unit
 suite = do
   test "basic asserts" do
     Assert.assert "wasn't true" true
@@ -41,16 +39,13 @@ suite = do
       TU.failure "This one fails"
 
 -- | interpret runs a `Plan` to produce a `TestSuite`
-interpret
-  ∷ ∀ bracket eff
-  . Plan bracket (Test eff)
-  → TestSuite eff
+interpret ∷ ∀ bracket. Plan bracket Test → TestSuite
 interpret =
   foldPlan
     (\ { label, value } -> TU.test label value)
     (\label -> TU.testSkip label (pure unit))
     (\ { label, value } -> TU.suite label (interpret value))
     sequence_
 
-main ∷ ∀ e. Eff _ Unit
+main ∷ Effect Unit
 main = launchAff_ (moteTCli (runTestWith Fancy.runTest <<< interpret) suite)

package.json

@@ -5,7 +5,7 @@
     "example:run": "node example/run.js"
   },
   "dependencies": {
-    "pulp": "^12.0.1",
-    "purescript": "^0.11.7"
+    "pulp": "^12.2.0",
+    "purescript": "slamdata/node-purescript#0.12"
   }
 }

src/MoteRunner.purs

@@ -2,58 +2,57 @@ module MoteRunner (moteCli, moteTCli) where
 
 import Prelude
 
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
-import Control.Monad.Eff.Console (CONSOLE, log)
 import Control.MonadPlus (guard)
 import Data.Array as Array
 import Data.Either (Either(..))
 import Data.Maybe (Maybe(..), maybe)
 import Data.Traversable (for_)
+import Effect.Class (class MonadEffect, liftEffect)
+import Effect.Console (log)
 import Mote.Monad (MoteT, Mote)
 import Mote.Monad as MoteM
 import Mote.Plan (Plan(..), PlanItem, foldPlan)
 import Mote.Plan as Plan
 import MoteRunner.Options (Config, parseConfig)
-import Node.Process (PROCESS)
 import Node.Process as Process
 
 -- | Accepts a `MoteT` suite of tests, an interpreter and returns a command-line
 -- | application that supports running individual tests, and inspection of the
 -- | test plan.
 moteCli
-  ∷ ∀ void void' test bracket m e
-  . MonadEff (process ∷ PROCESS, console ∷ CONSOLE | e) m
+  ∷ ∀ void void' test bracket m
+  . MonadEffect m
   ⇒ (Plan bracket test → m void)
   → Mote bracket test void'
   → m Unit
 moteCli interpret suite = do
   config ← getConfig
   let plan = filterPlanM config.pattern (MoteM.plan suite)
   if config.list
-    then liftEff (for_ (listPlan plan) log)
+    then liftEffect (for_ (listPlan plan) log)
     else void (interpret plan)
 
 -- | Like moteCli, but supports effectful construction of the test plan in MonadEff.
 moteTCli
-  ∷ ∀ bracket test void void' e m
-  . MonadEff (process ∷ PROCESS, console ∷ CONSOLE | e) m
+  ∷ ∀ bracket test void void' m
+  . MonadEffect m
   ⇒ (Plan.Plan bracket test → m void')
   → MoteT bracket test m void
   → m Unit
 moteTCli interpret suite = do
   config ← getConfig
   plan ← filterPlanM config.pattern <$> MoteM.planT suite
   if config.list
-    then liftEff (for_ (listPlan plan) log)
+    then liftEffect (for_ (listPlan plan) log)
     else void (interpret plan)
 
 getConfig
-  ∷ ∀ m e
-  . MonadEff (process ∷ PROCESS, console ∷ CONSOLE | e) m
+  ∷ ∀ m
+  . MonadEffect m
   ⇒ m Config
 getConfig = do
-  liftEff parseConfig >>= case _ of
-    Left err → liftEff do
+  liftEffect parseConfig >>= case _ of
+    Left err → liftEffect do
       log err
       Process.exit 1
     Right config →
@@ -66,11 +65,20 @@ listPlan = foldPlan
   (\ { label, value } -> map ((label <> "/") <> _) (listPlan value))
   join
 
-filterPlanM ∷ ∀ bracket test. Maybe String → Plan bracket test → Plan bracket test
-filterPlanM = maybe id filterPlan
+filterPlanM
+  ∷ ∀ bracket test
+  . Maybe String
+  → Plan bracket test
+  → Plan bracket test
+filterPlanM = maybe identity filterPlan
 
-filterPlan ∷ ∀ bracket test. String → Plan bracket test → Plan bracket test
-filterPlan pattern (Plan items) = Plan (Array.mapMaybe (shouldKeep pattern) items)
+filterPlan
+  ∷ ∀ bracket test
+  . String
+  → Plan bracket test
+  → Plan bracket test
+filterPlan pattern (Plan items) =
+  Plan (Array.mapMaybe (shouldKeep pattern) items)
 
 unPlan ∷ ∀ bracket test. Plan bracket test → Array (PlanItem bracket test)
 unPlan (Plan p) = p

src/MoteRunner/Options.purs

@@ -2,21 +2,18 @@ module MoteRunner.Options where
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
+import Effect (Effect)
 import Data.Either (Either(..))
 import Data.Maybe (Maybe(..))
 import Data.Validation.Semigroup (unV)
 import Node.Optlicative (Optlicative, defaultPreferences, flag, optional, optlicate, renderErrors, string)
-import Node.Process (PROCESS)
 
 type Config =
   { pattern ∷ Maybe String
   , list ∷ Boolean
   }
 
-parseConfig
-  ∷ ∀ e
-  . Eff (process ∷ PROCESS | e) (Either String Config)
+parseConfig ∷ Effect (Either String Config)
 parseConfig = do
   { value } ← optlicate {} (defaultPreferences { globalOpts = parseConfig' })
   pure $ unV (Left <<< renderErrors) Right value