Refactor in preparation for hex numbers

Author: robinheghan

src/Parse/Number.gren

@@ -1,6 +1,5 @@
 module Parse.Number exposing
-    ( Format (..)
-    , Outcome (..)
+    ( Outcome (..)
     , Error (..)
     , parser
     )
@@ -9,14 +8,10 @@ module Parse.Number exposing
 import Parser.Advanced as Parser exposing (Parser)
 
 
-type Format
-    = Decimal
-    | Hex
-
-
 type Outcome
-    = Integer { format: Format, value : Int }
+    = Integer Int
     | FloatingPoint Float
+    | Hex Int
 
 
 type Error
@@ -27,41 +22,84 @@ type Error
 
 parser : Parser c Error Outcome
 parser =
-    Parser.chompIf (\c -> c == '-' || Char.isDigit c) NotANumber
-        |> Parser.skip (Parser.chompWhile Char.isDigit)
-        |> Parser.getChompedString
+    Parser.oneOf
+        [ Parser.succeed
+            (\outcome ->
+                when outcome is
+                    Integer int ->
+                        Integer (negate int)
+
+                    FloatingPoint float ->
+                        FloatingPoint (negate float)
+
+                    Hex hex ->
+                        Hex (negate hex)
+            )
+            |> Parser.skip (Parser.symbol negateSign)
+            |> Parser.keep numParser
+        , numParser
+        ]
         |> Parser.andThen
-            (\str ->
-                if String.count str > 1 && (String.startsWith "0" str || String.startsWith "-0" str) then
-                    Parser.problem LeadingZero
+            (\successCase ->
+                Parser.oneOf
+                    [ Parser.chompIf Char.isAlpha NotANumber
+                        |> Parser.andThen (\_ -> Parser.problem NotANumber)
+                    , Parser.succeed successCase
+                    ]
+            )
+
 
-                else
+negateSign : Parser.Token Error
+negateSign =
+    Parser.Token { str = "-", expecting = NotANumber }
+
+
+numParser : Parser c Error Outcome
+numParser =
+    Parser.oneOf
+        [ Parser.chompIf (\c -> c == '0') NotANumber
+            |> Parser.andThen
+                (\_ ->
+                    Parser.oneOf
+                        [ Parser.chompIf (\c -> c == 'x') NotANumber
+                            |> Parser.andThen (\_ -> Parser.succeed (Hex 0))
+                        , Parser.chompIf (\c -> c == '.') NotANumber
+                            |> Parser.andThen (\_ -> fractalParser "0")
+                        , Parser.chompIf Char.isDigit NotANumber
+                            |> Parser.andThen (\_ -> Parser.problem LeadingZero)
+                        , Parser.succeed (Integer 0)
+                        ]
+                )
+        , Parser.chompIf Char.isDigit NotANumber
+            |> Parser.skip (Parser.chompWhile Char.isDigit)
+            |> Parser.getChompedString
+            |> Parser.andThen
+                (\str ->
                     when String.toInt str is
                         Nothing ->
                             Parser.problem NotANumber
 
                         Just num ->
                             Parser.oneOf
                                 [ Parser.chompIf (\c -> c == '.') NotANumber
-                                    |> Parser.skip (Parser.chompWhile Char.isDigit)
-                                    |> Parser.getChompedString
-                                    |> Parser.andThen
-                                        (\postDot ->
-                                            if postDot == "." then
-                                                Parser.problem TerminatingDot
-
-                                            else
-                                                when String.toFloat (str ++ postDot) is
-                                                    Nothing ->
-                                                        Parser.problem NotANumber
-
-                                                    Just float ->
-                                                        Parser.succeed (FloatingPoint float)
-                                        )
-                                , Parser.succeed <|
-                                    Integer
-                                        { format = Decimal
-                                        , value = num
-                                        }
+                                    |> Parser.andThen (\_ -> fractalParser str)
+                                , Parser.succeed (Integer num)
                                 ]
+                )
+        ]
+
+
+fractalParser : String -> Parser c Error Outcome
+fractalParser str =
+    Parser.chompIf Char.isDigit TerminatingDot
+        |> Parser.skip (Parser.chompWhile Char.isDigit)
+        |> Parser.getChompedString
+        |> Parser.andThen
+            (\postDot ->
+                when String.toFloat (str ++ "." ++ postDot) is
+                    Nothing ->
+                        Parser.problem NotANumber
+
+                    Just float ->
+                        Parser.succeed (FloatingPoint float)
             )

tests/src/Test/Parse/Number.gren

@@ -13,7 +13,7 @@ tests =
         [ describe "Integers"
             [ fuzz Fuzz.int "Can parse regular integers" <| \int ->
                 run (String.fromInt int)
-                    |> Expect.equal (Ok (PN.Integer { format = PN.Decimal, value = int }))
+                    |> Expect.equal (Ok (PN.Integer int))
             , test "empty string fails" <| \{} ->
                 run ""
                     |> expectErr PN.NotANumber
@@ -23,14 +23,17 @@ tests =
             , test "leading negative 0 fails" <| \{} ->
                 run "-012"
                     |> expectErr PN.LeadingZero
+            , test "when followed by letter, it fails" <| \{} ->
+                run "123a"
+                    |> expectErr PN.NotANumber
             ]
         , describe "Floats"
             [ fuzz (Fuzz.floatRange 0 32000) "Can parse regular floats" <| \float ->
                 run (String.fromFloat float)
                     |> Result.map
                         (\outcome ->
                             when outcome is
-                                PN.Integer { value } -> 
+                                PN.Integer value -> 
                                     PN.FloatingPoint (toFloat value)
 
                                 _ ->
@@ -40,6 +43,14 @@ tests =
             , test "Requires a number after ." <| \{} ->
                 run "0."
                     |> expectErr PN.TerminatingDot
+            , test "when followed by letter, it fails" <| \{} ->
+                run "0.15a"
+                    |> expectErr PN.NotANumber
+            ]
+        , describe "Hex"
+            [ test "Can parse hex" <| \{} ->
+                run "0xAFFE"
+                    |> Expect.equal (Ok (PN.Hex 45054))
             ]
         ]