Merge branch 'compiler/0.12' into nonemptyarray

Author: garyb

bower.json

@@ -17,17 +17,17 @@
     "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.3.0",
-    "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-minibench": "^1.0.1"
+    "purescript-assert": "#compiler/0.12",
+    "purescript-console": "#compiler/0.12",
+    "purescript-minibench": "#compiler/0.12"
   }
 }

package.json

@@ -4,7 +4,6 @@
     "clean": "rimraf output && rimraf .pulp-cache",
     "build": "eslint src && pulp build -- --censor-lib --strict",
     "test": "pulp test",
-
     "bench:build": "purs compile 'bench/**/*.purs' 'src/**/*.purs' 'bower_components/*/src/**/*.purs'",
     "bench:run": "node --expose-gc -e 'require(\"./output/Bench.Main/index.js\").main()'",
     "bench": "npm run bench:build && npm run bench:run"

src/Data/String/Regex.js

@@ -46,7 +46,7 @@ exports._match = function (just) {
     return function (r) {
       return function (s) {
         var m = s.match(r);
-        if (m == null) {
+        if (m == null || m.length === 0) {
           return nothing;
         } else {
           for (var i = 0; i < m.length; i++) {

src/Data/String/Regex.purs

@@ -18,6 +18,7 @@ module Data.String.Regex
 
 import Prelude
 
+import Data.Array.NonEmpty (NonEmptyArray)
 import Data.Either (Either(..))
 import Data.Maybe (Maybe(..))
 import Data.String (Pattern(..), contains)
@@ -82,13 +83,13 @@ foreign import _match
   -> (forall r. Maybe r)
   -> Regex
   -> String
-  -> Maybe (Array (Maybe String))
+  -> Maybe (NonEmptyArray (Maybe String))
 
 -- | Matches the string against the `Regex` and returns an array of matches
 -- | if there were any. Each match has type `Maybe String`, where `Nothing`
 -- | represents an unmatched optional capturing group.
 -- | See [reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match).
-match :: Regex -> String -> Maybe (Array (Maybe String))
+match :: Regex -> String -> Maybe (NonEmptyArray (Maybe String))
 match = _match Just Nothing
 
 -- | Replaces occurences of the `Regex` with the first string. The replacement

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,18 +2,18 @@ module Test.Data.String.NonEmpty (testNonEmptyString) where
 
 import Data.String.NonEmpty
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
 import Data.Array.NonEmpty as NEA
 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 Effect (Effect)
+import Effect.Console (log)
 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