Added extra collect combinators as well as ~> and <~ (#53)

* Added extra collect combinators as well as ~> and <~

* Fixed collect

* Quick fix on CI

* gave collect new names to resolve stupid ambiguity

.github/workflows/ci.yaml

@@ -39,35 +39,35 @@ jobs:
 
     steps:
       - name: Checkout repository
-        if: needs.check-duplicate.outputs.should_skip != 'true'
+        #if: needs.check-duplicate.outputs.should_skip != 'true'
         uses: actions/[email protected]
 
       - name: Setup Scala
-        if: needs.check-duplicate.outputs.should_skip != 'true'
+        #if: needs.check-duplicate.outputs.should_skip != 'true'
         uses: olafurpg/setup-scala@v10
         with:
           java-version: ${{ matrix.java }}
 
       - name: Cache Coursier
-        if: needs.check-duplicate.outputs.should_skip != 'true'
+        #if: needs.check-duplicate.outputs.should_skip != 'true'
         uses: actions/cache@v2
         with:
           path: ~/.cache/coursier
           key: sbt-coursier-cache
 
       - name: Cache SBT
-        if: needs.check-duplicate.outputs.should_skip != 'true'
+        #if: needs.check-duplicate.outputs.should_skip != 'true'
         uses: actions/cache@v2
         with:
           path: ~/.sbt
           key: sbt-${{ hashFiles('**/build.sbt') }}
 
       - name: Test
-        if: needs.check-duplicate.outputs.should_skip != 'true'
+        #if: needs.check-duplicate.outputs.should_skip != 'true'
         run: sbt ++$SCALA_VERSION test
 
       - name: Scaladoc
-        if: needs.check-duplicate.outputs.should_skip != 'true'
+        #if: needs.check-duplicate.outputs.should_skip != 'true'
         run: sbt ++$SCALA_VERSION doc
 
   coverage:

src/main/scala/parsley/Parsley.scala

@@ -153,6 +153,20 @@ object Parsley
         def #>[B](x: B): Parsley[B] = this *> pure(x)
         /**This combinator is an alias for `*>`*/
         def >>[B](q: Parsley[B]): Parsley[B] = this *> q
+        /**
+          * This is the parser that corresponds to a more optimal version of `(p <~> q).map(_._2)`. It performs
+          * the parse action of both parsers, in order, but discards the result of the invokee.
+          * @param q The parser whose result should be returned
+          * @return A new parser which first parses `p`, then `q` and returns the result of `q`
+          */
+        def ~>[B](q: Parsley[B]): Parsley[B] = this *> q
+        /**
+          * This is the parser that corresponds to a more optimal version of `(p <~> q).map(_._1)`. It performs
+          * the parse action of both parsers, in order, but discards the result of the second parser.
+          * @param q The parser who should be executed but then discarded
+          * @return A new parser which first parses `p`, then `q` and returns the result of the `p`
+          */
+        def <~[B](q: Parsley[B]): Parsley[A] = this <* q
         /**This parser corresponds to `lift2(_+:_, p, ps)`.*/
         def <+:>[B >: A](ps: =>Parsley[Seq[B]]): Parsley[Seq[B]] = lift.lift2[A, Seq[B], Seq[B]](_ +: _, p, ps)
         /**This parser corresponds to `lift2(_::_, p, ps)`.*/
@@ -181,6 +195,22 @@ object Parsley
           * @since 1.7
           */
         def collect[B](pf: PartialFunction[A, B]): Parsley[B] = this.filter(pf.isDefinedAt).map(pf)
+        /** Attempts to first filter the parser to ensure that `pf` is defined over it. If it is, then the function `pf`
+          * is mapped over its result. Roughly the same as a `guard` then a `map`.
+          * @param pf The partial function
+          * @param msg The message used for the error if the input failed the check
+          * @return The result of applying `pf` to this parsers value (if possible), or fails
+          * @since 1.7
+          */
+        def collectMsg[B](msg: String)(pf: PartialFunction[A, B]): Parsley[B] = this.guard(pf.isDefinedAt(_), msg).map(pf)
+        /** Attempts to first filter the parser to ensure that `pf` is defined over it. If it is, then the function `pf`
+          * is mapped over its result. Roughly the same as a `guard` then a `map`.
+          * @param pf The partial function
+          * @param msggen Generator function for error message, generating a message based on the result of the parser
+          * @return The result of applying `pf` to this parsers value (if possible), or fails
+          * @since 1.7
+          */
+        def collectMsg[B](msggen: A => String)(pf: PartialFunction[A, B]): Parsley[B] = this.guard(pf.isDefinedAt(_), msggen).map(pf)
         /** Similar to `filter`, except the error message desired is also provided. This allows you to name the message
           * itself.
           * @param pred The predicate that is tested against the parser result

src/test/scala/parsley/CoreTests.scala

@@ -35,7 +35,7 @@ class CoreTests extends ParsleyTest {
             case Failure(err) => err should startWith ("(line 1, column 2)")
             case _ =>
         }
-        res = ('a' *> 'b').runParser("bc")
+        res = ('a' ~> 'b').runParser("bc")
         res shouldBe a [Failure]
         res match {
             case Failure(err) => err should startWith ("(line 1, column 1)")
@@ -54,7 +54,7 @@ class CoreTests extends ParsleyTest {
     }
 
     they must "not consume any input" in {
-        (pure('a') *> 'a').runParser("a") should be (Success('a'))
+        (pure('a') <~ 'a').runParser("a") should be (Success('a'))
     }
 
     // APPLICATIVE LAWS
@@ -256,13 +256,29 @@ class CoreTests extends ParsleyTest {
     }
 
     "the collect combinator" should "act like a filter then a map" in {
-        val p = anyChar.collect {
+        val p = anyChar.collect[Int] {
             case '+' => 0
             case c if c.isUpper => c - 'A' + 1
         }
         p.runParser("+") shouldBe Success(0)
         p.runParser("C") shouldBe Success(3)
         p.runParser("a") shouldBe a [Failure]
+
+        val q = anyChar.collectMsg("oops") {
+            case '+' => 0
+            case c if c.isUpper => c - 'A' + 1
+        }
+        q.runParser("+") shouldBe Success(0)
+        q.runParser("C") shouldBe Success(3)
+        q.runParser("a") shouldBe Failure("(line 1, column 2):\n  oops")
+
+        val r = anyChar.collectMsg(c => s"$c is not appropriate") {
+            case '+' => 0
+            case c if c.isUpper => c - 'A' + 1
+        }
+        r.runParser("+") shouldBe Success(0)
+        r.runParser("C") shouldBe Success(3)
+        r.runParser("a") shouldBe Failure("(line 1, column 2):\n  a is not appropriate")
     }
 
     "the cast combinator" should "allow for casts to valid types" in {