Avoid backtracking in pattern parsers by requiring negative numbers to be wrapped in parens

Author: robinheghan

src/Compiler/Parse/Number.gren

@@ -2,6 +2,7 @@ module Compiler.Parse.Number exposing
     ( Outcome (..)
     , Error (..)
     , parser
+    , zeroOrHigher
     , hexParser
     , errorToString
     )
@@ -56,8 +57,8 @@ parser =
                         Hex (negate hex)
             )
             |> Parser.skip (Parser.token "-" NotANumber)
-            |> Parser.keep numParser
-        , numParser
+            |> Parser.keep zeroOrHigher
+        , zeroOrHigher
         ]
         |> Parser.andThen
             (\successCase ->
@@ -69,8 +70,8 @@ parser =
             )
 
 
-numParser : Parser Context Error Outcome
-numParser =
+zeroOrHigher : Parser Context Error Outcome
+zeroOrHigher =
     Parser.oneOf
         [ Parser.chompChar '0' NotANumber
             |> Parser.andThen

src/Compiler/Parse/Pattern.gren

@@ -172,7 +172,12 @@ parenthesized =
     Parser.succeed identity
         |> Parser.skip (Parser.chompChar '(' (ExpectedChar '('))
         -- When parens are used, allow `as` pattern
-        |> Parser.keep (Parser.lazy (\_ -> parser))
+        |> Parser.keep
+            (Parser.oneOf
+                [ SourcePosition.parser (numberBy Number.parser)
+                , Parser.lazy (\_ -> parser)
+                ]
+            )
         |> Parser.skip (Parser.chompChar ')' (ExpectedChar ')'))
 
 
@@ -192,18 +197,13 @@ term =
                         )
                 , lowerCaseVariable
                     |> Parser.map AST.PVar
-                , Parser.succeed (\start var end arg -> { ctor = SourcePosition.at start end var, arg = arg })
-                    |> Parser.keep Parser.getPosition
-                    |> Parser.keep Variable.foreignUpper
-                    |> Parser.mapError VariableError
-                    |> Parser.keep Parser.getPosition
+                , Parser.succeed (\var arg -> { ctor = var, arg = arg })
+                    |> Parser.keep (SourcePosition.parser (Parser.mapError VariableError Variable.foreignUpper))
                     |> Parser.skip spaceParser
                     |> Parser.keep
                         (Parser.oneOf
-                            [ Parser.lazy (\_ -> parserNoAlias)
-                                -- TODO: why backtrackable?
-                                |> Parser.backtrackable
-                                |> Parser.map Just
+                            [ Parser.succeed Just
+                                |> Parser.keep (Parser.lazy (\_ -> parserNoAlias))
                             , Parser.succeed Nothing
                             ]
                         )
@@ -224,20 +224,7 @@ term =
                                         , arg = arg
                                         }
                         )
-                , Number.parser
-                    |> Parser.mapError NumberError
-                    |> Parser.andThen
-                        (\num ->
-                            when num is
-                                Number.Integer int ->
-                                    Parser.succeed <| AST.PInt { isHex = False, value = int }
-
-                                Number.Hex int ->
-                                    Parser.succeed <| AST.PInt { isHex = True, value = int }
-
-                                Number.FloatingPoint _ ->
-                                    Parser.problem FloatNotSupported
-                        )
+                , numberBy Number.zeroOrHigher
                 , String.string
                     |> Parser.mapError StringError
                     |> Parser.map AST.PStr
@@ -280,3 +267,21 @@ spaceParser =
 lowerCaseVariable : Parser Context Error String
 lowerCaseVariable =
     Parser.mapError VariableError Variable.lowerCase
+
+
+numberBy : Parser Context Number.Error Number.Outcome -> Parser Context Error AST.Pattern_
+numberBy numParser =
+    numParser
+        |> Parser.mapError NumberError
+        |> Parser.andThen
+            (\num ->
+                when num is
+                    Number.Integer int ->
+                        Parser.succeed <| AST.PInt { isHex = False, value = int }
+
+                    Number.Hex int ->
+                        Parser.succeed <| AST.PInt { isHex = True, value = int }
+
+                    Number.FloatingPoint _ ->
+                        Parser.problem FloatNotSupported
+            )

tests/src/Test/Compiler/Parse/Pattern.gren

@@ -143,8 +143,9 @@ tests =
             Parser.run PT.parser Context.empty "160"
                 |> expectPattern
                     (AST.PInt { isHex = False, value = 160 })
-        , test "neagtive int" <| \_ ->
-            Parser.run PT.parser Context.empty "-10"
+        , test "negative int" <| \_ ->
+            -- Has to be wrapped in parens in case of '->'
+            Parser.run PT.parser Context.empty "(-10)"
                 |> expectPattern
                     (AST.PInt { isHex = False, value = -10 })
         , test "ints (hex)" <| \_ ->