fix count; implement dropWhile and takeWhile

src/Data/String/CodePoints.js

@@ -38,6 +38,30 @@ exports._codePointAt = function (fallback) {
   };
 };
 
+exports._count = function (isLead) {
+  return function (isTrail) {
+    return function (unsurrogate) {
+      return function (pred) {
+        return function (str) {
+          for (var cuCount = 0, cpCount = 0; cuCount < str.length; ++cuCount, ++cpCount) {
+            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;
+          }
+          return str.length;
+        };
+      };
+    };
+  };
+};
+
 exports.fromCodePointArray = function (cps) {
   if (hasFromCodePoint) {
     return String.fromCodePoint.apply(String, cps);

src/Data/String/CodePoints.purs

@@ -6,7 +6,7 @@ module CodePoints
   , codePointToInt
   , count
   , drop
-  --, dropWhile
+  , dropWhile
   , fromCodePointArray
   --, indexOf
   --, indexOf'
@@ -16,7 +16,7 @@ module CodePoints
   , singleton
   , splitAt
   , take
-  --, takeWhile
+  , takeWhile
   , toCodePointArray
   , uncons
   ) where
@@ -31,6 +31,7 @@ import Data.Tuple (Tuple(Tuple))
 import Data.Unfoldable (unfoldr)
 import Prelude ((&&), (||), (*), (+), (-), (<$>), (<), (<=), (<<<))
 
+
 newtype CodePoint = CodePoint Int
 
 codePointFromInt :: Int -> Maybe CodePoint
@@ -42,11 +43,11 @@ codePointToInt (CodePoint n) = n
 
 codePointFromSurrogatePair :: Int -> Int -> Maybe CodePoint
 codePointFromSurrogatePair lead trail | isLead lead && isTrail trail
-  = Just (CodePoint (unsurrogate lead trail))
+  = Just (unsurrogate lead trail)
 codePointFromSurrogatePair _ _ = Nothing
 
-unsurrogate :: Int -> Int -> Int
-unsurrogate h l = (h - 0xD800) * 0x400 + (l - 0xDC00) + 0x10000
+unsurrogate :: Int -> Int -> CodePoint
+unsurrogate h l = CodePoint ((h - 0xD800) * 0x400 + (l - 0xDC00) + 0x10000)
 
 isLead :: Int -> Boolean
 isLead cu = 0xD800 <= cu && cu <= 0xDBFF
@@ -71,13 +72,25 @@ codePointAtFallback n s = Array.index (toCodePointArray s) n
 
 
 count :: (CodePoint -> Boolean) -> String -> Int
-count pred = Array.length <<< Array.filter pred <<< toCodePointArray
+count = _count isLead isTrail unsurrogate
+
+foreign import _count
+  :: (Int -> Boolean)
+  -> (Int -> Boolean)
+  -> (Int -> Int -> CodePoint)
+  -> (CodePoint -> Boolean)
+  -> String
+  -> Int
 
 
 drop :: Int -> String -> String
 drop n s = fromCodePointArray (Array.drop n (toCodePointArray s))
 
 
+dropWhile :: (CodePoint -> Boolean) -> String -> String
+dropWhile p s = drop (count p s) s
+
+
 foreign import fromCodePointArray :: Array CodePoint -> String
 
 
@@ -108,6 +121,10 @@ takeFallback :: Int -> String -> String
 takeFallback n s = fromCodePointArray (Array.take n (toCodePointArray s))
 
 
+takeWhile :: (CodePoint -> Boolean) -> String -> String
+takeWhile p s = take (count p s) s
+
+
 toCodePointArray :: String -> Array CodePoint
 toCodePointArray = _toCodePointArray toCodePointArrayFallback
 
@@ -121,7 +138,7 @@ toCodePointArrayFallback s = unfoldr decode (fromFoldable (toCharCode <$> toChar
   where
   decode :: List Int -> Maybe (Tuple CodePoint (List Int))
   decode (Cons h (Cons l rest)) | isLead h && isTrail l
-    = Just (Tuple (CodePoint (unsurrogate h l)) rest)
+    = Just (Tuple (unsurrogate h l) rest)
   decode (Cons c rest) = Just (Tuple (CodePoint c) rest)
   decode Nil = Nothing