Added function equivalents of |. and |= operators

Author: robinheghan

src/Parser.gren

@@ -1,7 +1,7 @@
 module Parser exposing
   ( Parser, run
   , int, float, number, symbol, keyword, variable, end
-  , succeed, (|=), (|.), lazy, andThen, problem
+  , succeed, (|=), (|.), keep, skip, lazy, andThen, problem
   , oneOf, map, backtrackable, commit, token
   , sequence, Trailing(..), loop, Step(..)
   , spaces, lineComment, multiComment, Nestable(..)
@@ -291,6 +291,16 @@ ignorer =
   (|.)
 
 
+keep : Parser keep -> Parser (keep -> b) -> Parser b
+keep =
+  A.keep
+
+
+skip : Parser ignore -> Parser kept -> Parser kept
+skip =
+  A.skip
+
+
 {-| Helper to define recursive parsers. Say we want a parser for simple
 boolean expressions:
 

src/Parser/Advanced.gren

@@ -1,7 +1,7 @@
 module Parser.Advanced exposing
   ( Parser, run, DeadEnd, inContext, Token(..)
   , int, float, number, symbol, keyword, variable, end
-  , succeed, (|=), (|.), lazy, andThen, problem
+  , succeed, (|=), (|.), keep, skip, lazy, andThen, problem
   , oneOf, map, backtrackable, commit, token
   , sequence, Trailing(..), loop, Step(..)
   , spaces, lineComment, multiComment, Nestable(..)
@@ -322,6 +322,19 @@ ignorer keepParser ignoreParser =
   map2 (\val _ -> val) keepParser ignoreParser
 
 
+{-| Just like the [`(|=)`](Parser#|=) from the `Parser` module.
+-}
+keep : Parser c x a -> Parser c x (a -> b) -> Parser c x b
+keep parseArg parseFunc =
+  map2 (<|) parseFunc parseArg
+
+
+{-| Just like the [`(|.)`](Parser#|.) from the `Parser` module.
+-}
+skip : Parser c x ignore -> Parser c x keep -> Parser c x keep
+skip ignoreParser keepParser =
+  map2 (\val _ -> val) keepParser ignoreParser
+
 
 -- AND THEN
 
@@ -1254,8 +1267,8 @@ sequence
     }
   -> Parser c x (Array a)
 sequence i =
-  skip (token i.start) <|
-  skip i.spaces <|
+  seqSkip (token i.start) <|
+  seqSkip i.spaces <|
     sequenceEnd (token i.end) i.spaces i.item (token i.separator) i.trailing
 
 
@@ -1266,8 +1279,8 @@ club](https://poorlydrawnlines.com/comic/shapes-club/)!
 type Trailing = Forbidden | Optional | Mandatory
 
 
-skip : Parser c x ignore -> Parser c x keep -> Parser c x keep
-skip iParser kParser =
+seqSkip : Parser c x ignore -> Parser c x keep -> Parser c x keep
+seqSkip iParser kParser =
   map2 revAlways iParser kParser
 
 

tests/src/Main.gren

@@ -3,7 +3,7 @@ module Main exposing (main)
 import Expect
 import Test exposing (describe, test)
 import Test.Runner.Node exposing (Program, run)
-import Parser as P
+import Parser as P exposing ((|.), (|=))
 
 
 
@@ -19,6 +19,28 @@ main =
                     P.run P.int "3.1415"
                         |> expectErr
                 ]
+            , describe "combinators"
+                [ test "functions" <| \{} ->
+                    let
+                        parser =
+                            P.succeed (\a b -> a + b)
+                                |> P.keep P.int
+                                |> P.skip (P.symbol "+")
+                                |> P.keep P.int
+                    in
+                    P.run parser "3+5"
+                        |> Expect.equal (Ok 8)
+                , test "operators" <| \{} ->
+                    let
+                        parser =
+                            P.succeed (\a b -> a + b)
+                                |= P.int
+                                |. P.symbol "+"
+                                |= P.int
+                    in
+                    P.run parser "2+2"
+                        |> Expect.equal (Ok 4)
+                ]
             ]