Updates for 0.12

Author: garyb

bower.json

@@ -17,16 +17,16 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-either": "^3.0.0",
-    "purescript-gen": "^1.1.0",
-    "purescript-maybe": "^3.0.0",
-    "purescript-partial": "^1.2.0",
-    "purescript-unfoldable": "^3.0.0",
-    "purescript-arrays": "^4.0.1",
-    "purescript-integers": "^3.2.0"
+    "purescript-either": "#compiler/0.12",
+    "purescript-gen": "#compiler/0.12",
+    "purescript-maybe": "#compiler/0.12",
+    "purescript-partial": "#compiler/0.12",
+    "purescript-unfoldable": "#compiler/0.12",
+    "purescript-arrays": "#compiler/0.12",
+    "purescript-integers": "#compiler/0.12"
   },
   "devDependencies": {
-    "purescript-assert": "^3.0.0",
-    "purescript-console": "^3.0.0"
+    "purescript-assert": "#compiler/0.12",
+    "purescript-console": "#compiler/0.12"
   }
 }

src/Data/String/Regex/Flags.purs

@@ -3,8 +3,6 @@ module Data.String.Regex.Flags where
 import Prelude
 
 import Control.MonadPlus (guard)
-
-import Data.Monoid (class Monoid)
 import Data.String (joinWith)
 
 type RegexFlagsRec =

test/Test/Data/Char.purs

@@ -2,14 +2,14 @@ module Test.Data.Char (testChar) where
 
 import Prelude (Unit, (==), ($), discard)
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
+import Effect (Effect)
+import Effect.Console (log)
 
 import Data.Char
 
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
-testChar :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
+testChar :: Effect Unit
 testChar = do
   log "toCharCode"
   assert $ toCharCode 'a' == 97

test/Test/Data/String.purs

@@ -2,15 +2,15 @@ module Test.Data.String (testString) where
 
 import Prelude (Unit, Ordering(..), (==), ($), discard, negate, not, (/=), (&&))
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
+import Effect (Effect)
+import Effect.Console (log)
 
 import Data.Maybe (Maybe(..), isNothing, maybe)
 import Data.String
 
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
-testString :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
+testString :: Effect Unit
 testString = do
   log "charAt"
   assert $ charAt 0 "" == Nothing

test/Test/Data/String/CaseInsensitive.purs

@@ -2,14 +2,14 @@ module Test.Data.String.CaseInsensitive (testCaseInsensitiveString) where
 
 import Prelude (Unit, (==), ($), discard, compare, Ordering(..))
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
+import Effect (Effect)
+import Effect.Console (log)
 
 import Data.String.CaseInsensitive
 
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
-testCaseInsensitiveString :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
+testCaseInsensitiveString :: Effect Unit
 testCaseInsensitiveString = do
   log "equality"
   assert $ CaseInsensitiveString "aB" == CaseInsensitiveString "AB"

test/Test/Data/String/CodePoints.purs

@@ -2,19 +2,19 @@ module Test.Data.String.CodePoints (testStringCodePoints) where
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
+import Effect (Effect)
+import Effect.Console (log)
 
 import Data.Char (fromCharCode)
 import Data.Maybe (Maybe(..), isNothing, maybe)
 import Data.String.CodePoints
 
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
 str :: String
 str = "a\xDC00\xD800\xD800\x16805\x16A06\&z"
 
-testStringCodePoints :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
+testStringCodePoints :: Effect Unit
 testStringCodePoints = do
   log "show"
   assert $ map show (codePointAt 0 str) == Just "(CodePoint 0x61)"

test/Test/Data/String/NonEmpty.purs

@@ -2,17 +2,17 @@ module Test.Data.String.NonEmpty (testNonEmptyString) where
 
 import Data.String.NonEmpty
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
+import Effect (Effect)
+import Effect.Console (log)
 import Data.Array.Partial as AP
 import Data.Foldable (class Foldable, foldl)
 import Data.Maybe (Maybe(..), fromJust, isNothing, maybe)
 import Data.Semigroup.Foldable (class Foldable1, foldMap1Default)
 import Partial.Unsafe (unsafePartial)
 import Prelude (class Functor, Ordering(..), Unit, append, discard, negate, not, ($), (&&), (/=), (==))
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
-testNonEmptyString :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
+testNonEmptyString :: Effect Unit
 testNonEmptyString = do
   log "fromString"
   assert $ fromString "" == Nothing

test/Test/Data/String/Regex.purs

@@ -2,18 +2,18 @@ module Test.Data.String.Regex (testStringRegex) where
 
 import Prelude (Unit, ($), (<>), discard, (==), not)
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
+import Effect (Effect)
+import Effect.Console (log)
 
 import Data.Either (isLeft)
 import Data.Maybe (Maybe(..))
 import Data.String.Regex
 import Data.String.Regex.Flags (global, ignoreCase, noFlags)
 import Data.String.Regex.Unsafe (unsafeRegex)
 
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
-testStringRegex :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
+testStringRegex :: Effect Unit
 testStringRegex = do
   log "regex"
   assert $ test (unsafeRegex "^a" noFlags) "abc"

test/Test/Data/String/Unsafe.purs

@@ -2,14 +2,14 @@ module Test.Data.String.Unsafe (testStringUnsafe) where
 
 import Prelude (Unit, (==), ($), discard)
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
+import Effect (Effect)
+import Effect.Console (log)
 
 import Data.String.Unsafe
 
-import Test.Assert (ASSERT, assert)
+import Test.Assert (assert)
 
-testStringUnsafe :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
+testStringUnsafe :: Effect Unit
 testStringUnsafe = do
   log "charCodeAt"
   assert $ charCodeAt 0 "ab" == 97

test/Test/Main.purs

@@ -2,9 +2,8 @@ module Test.Main where
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
-import Test.Assert (ASSERT)
+import Effect (Effect)
+import Effect.Console (log)
 import Test.Data.Char (testChar)
 import Test.Data.String (testString)
 import Test.Data.String.CaseInsensitive (testCaseInsensitiveString)
@@ -13,7 +12,7 @@ import Test.Data.String.NonEmpty (testNonEmptyString)
 import Test.Data.String.Regex (testStringRegex)
 import Test.Data.String.Unsafe (testStringUnsafe)
 
-main :: Eff (console :: CONSOLE, assert :: ASSERT) Unit
+main :: Effect Unit
 main = do
   log "\n--- Data.Char ---\n"
   testChar