move 'digit' to parser.number

Author: safareli

src/Data/Formatter/DateTime.purs

@@ -32,7 +32,8 @@ import Data.String as Str
 import Data.Time as T
 import Data.Time.Duration as Dur
 import Data.Tuple (Tuple(..))
-import Data.Formatter.Internal (digit, foldDigits)
+import Data.Formatter.Internal (foldDigits)
+import Data.Formatter.Parser.Number (parseDigit)
 
 import Text.Parsing.Parser as P
 import Text.Parsing.Parser.Combinators as PC
@@ -292,19 +293,19 @@ unformatFParser
   → P.ParserT String (State UnformatAccum) Unit
 unformatFParser cb = case _ of
   YearFull a → do
-    ds ← some digit
+    ds ← some parseDigit
     when (Arr.length ds /= 4) $ P.fail "Incorrect full year"
     lift $ modify _{year = Just $ foldDigits ds}
     cb a
   YearTwoDigits a → do
-    ds ← some digit
+    ds ← some parseDigit
     when (Arr.length ds /= 2) $ P.fail "Incorrect 2-digit year"
     let y = foldDigits ds
     lift $ modify _{year = Just $ if y > 69 then y + 1900 else y + 2000}
     cb a
   YearAbsolute a → do
     sign ← PC.optionMaybe $ PC.try $ PS.string "-"
-    year ← map foldDigits $ some digit
+    year ← map foldDigits $ some parseDigit
     lift $ modify _{year = Just $ (if isJust sign then -1 else 1) * year}
     cb a
   MonthFull a → do
@@ -316,25 +317,25 @@ unformatFParser cb = case _ of
     lift $ modify _{month = Just $ fromEnum month}
     cb a
   MonthTwoDigits a → do
-    ds ← some digit
+    ds ← some parseDigit
     let month = foldDigits ds
     when (Arr.length ds /= 2 || month > 12 || month < 1) $ P.fail "Incorrect 2-digit month"
     lift $ modify _{month = Just month}
     cb a
   DayOfMonthTwoDigits a → do
-    ds ← some digit
+    ds ← some parseDigit
     let dom = foldDigits ds
     when (Arr.length ds /= 2 || dom > 31 || dom < 1) $ P.fail "Incorrect day of month"
     lift $ modify _{day = Just dom}
     cb a
   DayOfMonth a → do
-    ds ← some digit
+    ds ← some parseDigit
     let dom = foldDigits ds
     when (Arr.length ds > 2 || dom > 31 || dom < 1) $ P.fail "Incorrect day of month"
     lift $ modify _{day = Just dom}
     cb a
   UnixTimestamp a → do
-    s ← map foldDigits $ some digit
+    s ← map foldDigits $ some parseDigit
     case map toDateTime $ instant $ Dur.Milliseconds $ 1000.0 * Int.toNumber s of
       Nothing → P.fail "Incorrect timestamp"
       Just (DT.DateTime d t) → do
@@ -349,17 +350,17 @@ unformatFParser cb = case _ of
                    }
         cb a
   DayOfWeek a → do
-    dow ← digit
+    dow ← parseDigit
     when (dow > 7 || dow < 1) $ P.fail "Incorrect day of week"
     cb a
   Hours24 a → do
-    ds ← some digit
+    ds ← some parseDigit
     let hh = foldDigits ds
     when (Arr.length ds /= 2 || hh < 0 || hh > 23) $ P.fail "Incorrect 24 hour"
     lift $ modify _{hour = Just hh}
     cb a
   Hours12 a → do
-    ds ← some digit
+    ds ← some parseDigit
     let hh = foldDigits ds
     when (Arr.length ds /= 2 || hh < 0 || hh > 11) $ P.fail "Incorrect 24 hour"
     lift $ modify _{hour = Just hh}
@@ -377,19 +378,19 @@ unformatFParser cb = case _ of
     lift $ modify f
     cb a
   Minutes a → do
-    ds ← some digit
+    ds ← some parseDigit
     let mm = foldDigits ds
     when (Arr.length ds /= 2 || mm < 0 || mm > 59) $ P.fail "Incorrect minute"
     lift $ modify _{minute = Just mm}
     cb a
   Seconds a → do
-    ds ← some digit
+    ds ← some parseDigit
     let ss = foldDigits ds
     when (Arr.length ds /= 2 || ss < 0 || ss > 59) $ P.fail "Incorrect second"
     lift $ modify _{second = Just ss}
     cb a
   Milliseconds a → do
-    ds ← some digit
+    ds ← some parseDigit
     let sss = foldDigits ds
     when (Arr.length ds /= 3 || sss < 0 || sss > 999) $ P.fail "Incorrect millisecond"
     lift $ modify _{millisecond = Just sss}

src/Data/Formatter/Internal.purs

@@ -11,37 +11,6 @@ import Text.Parsing.Parser.String as PS
 foldDigits ∷ ∀ f. Foldable f ⇒ f Int → Int
 foldDigits = foldl (\acc d → acc * 10 + d) zero
 
--- TODO move to Parser.Number
-digit ∷ ∀ m. Monad m ⇒ P.ParserT String m Int
-digit = do
-  char ← PS.oneOf ['0','1','2','3','4','5','6','7','8','9']
-  case char of
-    '0' → pure 0
-    '1' → pure 1
-    '2' → pure 2
-    '3' → pure 3
-    '4' → pure 4
-    '5' → pure 5
-    '6' → pure 6
-    '7' → pure 7
-    '8' → pure 8
-    '9' → pure 9
-    _ → P.fail "Incorrect digit, impossible situation"
-
--- https://github.com/purescript-contrib/purescript-parsing/issues/50
--- digit ∷ ∀ m. Monad m ⇒ P.ParserT String m Int
--- digit = PS.oneOfAs $
---   [ Tuple '0' 0
---   , Tuple '1' 1
---   , Tuple '2' 2
---   , Tuple '3' 3
---   , Tuple '4' 4
---   , Tuple '5' 5
---   , Tuple '6' 6
---   , Tuple '7' 7
---   , Tuple '8' 8
---   , Tuple '9' 9]
-
 repeat ∷ ∀ a. Monoid a ⇒ a → Int → a
 repeat = repeat' mempty
   where

src/Data/Formatter/Number.purs

@@ -24,7 +24,8 @@ import Data.Either (Either, either)
 import Data.Int as Int
 import Data.String as Str
 
-import Data.Formatter.Internal (foldDigits, digit, repeat)
+import Data.Formatter.Internal (foldDigits, repeat)
+import Data.Formatter.Parser.Number (parseDigit)
 
 import Math as Math
 
@@ -149,13 +150,13 @@ unformatParser f = do
     digitsWithCommas =
       if not f.comma
         then do
-        some digit <* PS.string "."
+        some parseDigit <* PS.string "."
         else
         digitsWithCommas' [ ]
 
     digitsWithCommas' ∷ Array Int → P.Parser String (Array Int)
     digitsWithCommas' accum = do
-      ds ← some digit
+      ds ← some parseDigit
 
       when (Arr.null accum && Arr.length ds > 3)
         $ P.fail "Wrong number of digits between thousand separators"
@@ -174,7 +175,7 @@ unformatParser f = do
     then P.fail "Error: too few digits before dot"
     else pure $ Int.toNumber $ foldDigits beforeDigits
 
-  afterDigits ← some digit
+  afterDigits ← some parseDigit
   after ←
     if Arr.length afterDigits < f.after
     then P.fail "Error: too few digits after dot"
@@ -191,7 +192,7 @@ unformatParser f = do
             Nothing →
               pure 0
             Just _ →
-              map foldDigits $ many digit
+              map foldDigits $ many parseDigit
         Just 'K' → pure 3
         Just 'M' → pure 6
         Just 'G' → pure 9

src/Data/Formatter/Parser/Number.purs

@@ -2,13 +2,14 @@ module Data.Formatter.Parser.Number
   ( parseInteger
   , parseMaybeInteger
   , parseNumber
+  , parseDigit
   ) where
 
 import Prelude
 
 import Data.Int (toNumber, floor)
 import Data.Array (some, many, length)
-import Data.Formatter.Internal (digit, foldDigits)
+import Data.Formatter.Internal (parseDigit, foldDigits)
 import Data.Function (on)
 import Text.Parsing.Parser as P
 import Text.Parsing.Parser.Combinators as PC
@@ -18,10 +19,10 @@ import Math as Math
 
 
 parseInteger ∷ P.Parser String Int
-parseInteger = some digit <#> foldDigits
+parseInteger = some parseDigit <#> foldDigits
 
 parseMaybeInteger ∷ P.Parser String (Maybe Int)
-parseMaybeInteger = many digit <#> (\l -> if length l == 0 then Nothing else Just $ foldDigits l)
+parseMaybeInteger = many parseDigit <#> (\l -> if length l == 0 then Nothing else Just $ foldDigits l)
 
 parseFractional ∷ P.Parser String Number
 parseFractional = parseInteger <#> case _ of
@@ -42,3 +43,18 @@ numOfDigits n = 1 + (floor $ log10 $ toNumber n)
 
 log10 ∷ Number → Number
 log10 n = Math.log10e * Math.log n
+
+parseDigit = PS.char `oneOfAs`
+    [ Tuple '0' 0
+    , Tuple '1' 1
+    , Tuple '2' 2
+    , Tuple '3' 3
+    , Tuple '4' 4
+    , Tuple '5' 5
+    , Tuple '6' 6
+    , Tuple '7' 7
+    , Tuple '8' 8
+    , Tuple '9' 9]
+  where
+  -- TODO remove after https://github.com/purescript-contrib/purescript-parsing/pull/51
+  oneOfAs p xs = choice $ (\(Tuple s r) -> try $ p s $> r) <$> xs