change JS implementation of count to use string iterator if possible

Author: michaelficarra

src/Data/String/CodePoints.js

@@ -40,29 +40,23 @@ exports._codePointAt = function (fallback) {
   };
 };
 
-exports._count = function (isLead) {
-  return function (isTrail) {
-    return function (unsurrogate) {
+exports._count = function (fallback) {
+  return function (unsafeCodePointAt0) {
+    if (hasStringIterator) {
       return function (pred) {
         return function (str) {
-          var cpCount = 0;
-          for (var cuCount = 0; cuCount < str.length; ++cuCount) {
-            var lead = str.charCodeAt(cuCount);
-            var cp = lead;
-            if (isLead(lead) && cuCount + 1 < str.length) {
-              var trail = str.charCodeAt(cuCount + 1);
-              if (isTrail(trail)) {
-                cp = unsurrogate(lead)(trail);
-                ++cuCount;
-              }
-            }
-            if (!pred(cp)) return cpCount;
-            ++cpCount;
+          var iter = str[Symbol.iterator]();
+          for (var i = 0; i < str.length; ++i) {
+            var o = iter.next();
+            if (o.done) return i;
+            var cp = unsafeCodePointAt0(o.value);
+            if (!pred(cp)) return i;
           }
-          return cpCount;
+          return i;
         };
       };
-    };
+    }
+    return fallback;
   };
 };
 

src/Data/String/CodePoints.purs

@@ -90,6 +90,7 @@ unsafeCodePointAt0Fallback s =
 -- | of code points from the beginning, if there is such a code point. Operates
 -- | in constant space and in time linear to `n`.
 codePointAt :: Int -> String -> Maybe CodePoint
+codePointAt n _ | n < 0 = Nothing
 codePointAt 0 "" = Nothing
 codePointAt 0 s = Just (unsafeCodePointAt0 s)
 codePointAt n s = _codePointAt codePointAtFallback Just Nothing unsafeCodePointAt0 n s
@@ -113,16 +114,23 @@ codePointAtFallback n s = case uncons s of
 -- | which all match the given predicate. Operates in constant space and in
 -- | time linear to the length of the given string.
 count :: (CodePoint -> Boolean) -> String -> Int
-count = _count isLead isTrail unsurrogate
+count = _count countFallback unsafeCodePointAt0
 
 foreign import _count
-  :: (Int -> Boolean)
-  -> (Int -> Boolean)
-  -> (Int -> Int -> CodePoint)
+  :: ((CodePoint -> Boolean) -> String -> Int)
+  -> (String -> CodePoint)
   -> (CodePoint -> Boolean)
   -> String
   -> Int
 
+countFallback :: (CodePoint -> Boolean) -> String -> Int
+countFallback p s = countTail p s 0
+  where
+  countTail :: (CodePoint -> Boolean) -> String -> Int -> Int
+  countTail p' s' accum = case uncons s' of
+    Just { head, tail } -> if p' head then countTail p' tail (accum + 1) else accum
+    _ -> accum
+
 
 -- | Drops the given number of code points from the beginning of the given
 -- | string. If the string does not have that many code points, returns the