Use NonEmptyArray for Regex match

Author: garyb

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

test/Test/Data/String/Regex.purs

@@ -1,16 +1,16 @@
 module Test.Data.String.Regex (testStringRegex) where
 
-import Prelude (Unit, ($), (<>), discard, (==), not)
-
-import Effect (Effect)
-import Effect.Console (log)
+import Data.String.Regex
 
+import Data.Array.NonEmpty (NonEmptyArray, fromArray)
 import Data.Either (isLeft)
-import Data.Maybe (Maybe(..))
-import Data.String.Regex
+import Data.Maybe (Maybe(..), fromJust)
 import Data.String.Regex.Flags (global, ignoreCase, noFlags)
 import Data.String.Regex.Unsafe (unsafeRegex)
-
+import Effect (Effect)
+import Effect.Console (log)
+import Partial.Unsafe (unsafePartial)
+import Prelude (type (~>), Unit, discard, not, ($), (<<<), (<>), (==))
 import Test.Assert (assert)
 
 testStringRegex :: Effect Unit
@@ -26,7 +26,8 @@ testStringRegex = do
   assert $ "quxbarquxbaz" == replace (unsafeRegex "foo" (global <> ignoreCase)) "qux" "foobarFOObaz"
 
   log "match"
-  assert $ match (unsafeRegex "^abc$" noFlags) "abc" == Just [Just "abc"]
+  assert $ match (unsafeRegex "^abc$" noFlags) "abc" == Just (nea [Just "abc"])
+  assert $ match (unsafeRegex "^abc$" noFlags) "xyz" == Nothing
 
   log "replace"
   assert $ replace (unsafeRegex "-" noFlags) "!" "a-b-c" == "a!b-c"
@@ -50,3 +51,6 @@ testStringRegex = do
   let pattern = unsafeRegex "a" (parseFlags "g")
   assert $ test pattern "a"
   assert $ test pattern "a"
+
+nea :: Array ~> NonEmptyArray
+nea = unsafePartial fromJust <<< fromArray