Make and chains with only one non-skipped component T return T, not tuple

Add operator equivalents to `and` & `skip`.

Author: h0tk3y

README.md

@@ -5,25 +5,25 @@
 A nice parser combinator library for Kotlin
 
 ```kotlin
-val booleanGrammar = object : Grammar<BooleanExpression>() {
-    val id by token("\\w+")
-    val not by token("!")
-    val and by token("&")
-    val or by token("|")
-    val ws by token("\\s+", ignore = true)
-    val lpar by token("\\(")
-    val rpar by token("\\)")
-
-    val term = 
-        (id use { Variable(text) }) or
-        (not and parser(this::term) map { (_, n) -> Not(n) }) or
-        (lpar and parser(this::rootParser) and rpar map { (_, e, _) -> e })
-
-    val andChain = leftAssociative(term, and) { l, _, r -> And(l, r) }
-    override val rootParser = leftAssociative(andChain, or) { l, _, r -> Or(l, r) }
-}
-
-val ast = booleanGrammar.parseToEnd("a & !b | b & (!a | c)")
+    val booleanGrammar = object : Grammar<BooleanExpression>() {
+        val id by token("\\w+")
+        val not by token("!")
+        val and by token("&")
+        val or by token("|")
+        val ws by token("\\s+", ignore = true)
+        val lpar by token("\\(")
+        val rpar by token("\\)")
+        
+        val term = 
+            (id use { Variable(text) }) or
+            (-not * parser(this::term) map { (Not(it) }) or
+            (-lpar * parser(this::rootParser) * -rpar)
+            
+        val andChain = leftAssociative(term, and) { l, _, r -> And(l, r) }
+        val rootParser = leftAssociative(andChain, or) { l, _, r -> Or(l, r) }
+    }
+    
+    val ast = booleanGrammar.parseToEnd("a & !b | b & (!a | c)")
  ```
 
 ### Using with Gradle
@@ -145,6 +145,9 @@ There are several kinds of combinators included in `better-parse`:
      val bbWithoutA = skip(a) and b and skip(a) and b and skip(a)  // Parser<Tuple2<B, B>>
      ```
       
+     > If all the components in an `and` chain are skipped except for one `Parser<T>`, the resulting parser
+      is `Parser<T>`, not `Parser<Tuple1<T>>`. 
+      
      To process the resulting `Tuple`, use the aforementioned `map` and `use`. These parsers are equivalent:
      
      * ```val fCall = id and skip(lpar) and id and skip(rpar) map { (fName, arg) -> FunctionCall(fName, arg) }```
@@ -155,6 +158,17 @@ There are several kinds of combinators included in `better-parse`:
      
      > There are `Tuple` classes up to `Tuple16` and the corresponding `and` overloads.
      
+     ##### Operators
+     
+     There are operator overloads for more compact `and` chains definition:
+     
+     * `a * b` is equivalent to `a and b`.
+     
+     * `-a` is equivalent to `skip(a)`.
+     
+     With these operators, the parser `a and skip(b) and skip(c) and d` can also be defined as 
+     `a * -b * -c * d`.
+     
  * `or`
  
      The alternative combinator tries to parse the sequence with the parsers it combines one by one until one succeeds. If all the parsers fail,
@@ -225,7 +239,7 @@ To use a parser that has not been constructed yet, reference it with `parser { s
 val term = 
     constParser or 
     variableParser or 
-    (skip(lpar) and parser(this::term) and skip(lpar) use { t1 })
+    (-lpar and parser(this::term) and -rpar)
 ```
         
 # Examples

build.gradle

@@ -1,5 +1,5 @@
 group 'com.github.h0tk3y.betterParse'
-version '0.1'
+version '0.2'
 
 wrapper {
     gradleVersion = '3.3'
@@ -18,6 +18,7 @@ buildscript {
 }
 
 apply plugin: 'kotlin'
+apply plugin: 'maven'
 
 repositories {
     jcenter()

buildSrc/src/main/kotlin/AndCodegen.kt

@@ -22,6 +22,11 @@ fun andCodegen(maxN: Int, outputFile: String) {
                     Tuple${i + 1}($casts)
                 })
                 """.trimIndent() + "\n")
+
+            appendln("""
+                @JvmName("and$i${"Operator"}") inline operator fun <$reifiedNext>
+                 AndCombinator<Tuple$i$generics>.times(p${i + 1}: Parser<T${i + 1}>) = this and p${i + 1}
+                """.trimIndent() + "\n\n")
         }
     }
 

demo/src/main/kotlin/com/example/ArithmeticsEvaluator.kt

@@ -19,8 +19,8 @@ class ArithmeticsEvaluator : Grammar<Int>() {
 
     val number = num use { text.toInt() }
     val term: Parser<Int> = number or
-        (skip(minus) and parser(this::term) use { -t1 }) or
-        (skip(lpar) and parser(this::rootParser) and skip(rpar) use { t1 })
+        (skip(minus) and parser(this::term) map { -it }) or
+        (skip(lpar) and parser(this::rootParser) and skip(rpar))
 
     val powChain = leftAssociative(term, pow) { a, _, b -> Math.pow(a.toDouble(), b.toDouble()).toInt() }
 

demo/src/main/kotlin/com/example/BooleanExpression.kt

@@ -30,11 +30,10 @@ val booleanGrammar = object : Grammar<BooleanExpression>() {
 
     val term: Parser<BooleanExpression> =
         (tru asJust TRUE) or
-            (fal asJust FALSE) or
-            (id map { Variable(it.text) }) or
-            (not and parser(this::term) map { (_, t) -> Not(t) }) or
-        (lpar and parser(this::implChain) and rpar map { (_, i, _) -> i })
-
+        (fal asJust FALSE) or
+        (id map { Variable(it.text) }) or
+        (-not * parser(this::term) map { Not(it) }) or
+        (-lpar * parser(this::implChain) * -rpar)
 
     val andChain = leftAssociative(term, and) { a, _, b -> And(a, b) }
     val orChain = leftAssociative(andChain, or) { a, _, b -> Or(a, b) }

src/main/kotlin/com/github/h0tk3y/betterParse/combinators/AndCombinator.kt

@@ -5,40 +5,44 @@ import com.github.h0tk3y.betterParse.parser.ErrorResult
 import com.github.h0tk3y.betterParse.parser.ParseResult
 import com.github.h0tk3y.betterParse.parser.Parsed
 import com.github.h0tk3y.betterParse.parser.Parser
-import com.github.h0tk3y.betterParse.utils.Tuple
-import com.github.h0tk3y.betterParse.utils.Tuple1
 import com.github.h0tk3y.betterParse.utils.Tuple2
 
 /** Parses the sequence with the receiver [Parser] and then with the [other] parser. If both suceed, returns a [Tuple2]
  * with the values from the [Parsed] results. Otherwise, returns the [ErrorResult] of the failed parser. */
 infix inline fun <reified A, reified B> Parser<A>.and(other: Parser<B>) =
     AndCombinator(listOf(this, other)) { (a1, a2) -> Tuple2(a1 as A, a2 as B) }
 
+/** The same as `this `[and]` other`*/
+operator inline fun <reified A, reified B> Parser<A>.times(other: Parser<B>) = this and other
+
 /** Parses the sequence with the receiver [Parser] and then with the [other] parser. If both suceed, returns a [Tuple2]
  * with the values from the [Parsed] results. Otherwise, returns the [ErrorResult] of the failed parser. */
-infix inline fun <reified A, reified B> AndCombinator<Tuple1<A>>.and(other: Parser<B>) =
-    AndCombinator(consumers + other) { (a1, a2) -> Tuple2(a1 as A, a2 as B) }
+@JvmName("and0")
+infix inline fun <reified A, reified B> AndCombinator<A>.and(other: Parser<B>) =
+    AndCombinator(consumers + listOf(other)) { (a1, a2) -> Tuple2(a1 as A, a2 as B) }
+
+/** The same as `this `[and]` other`*/
+operator inline fun <reified A, reified B> AndCombinator<A>.times(other: Parser<B>) = this and other
 
-class AndCombinator<out R : Tuple> internal @PublishedApi constructor(
+class AndCombinator<out R> internal @PublishedApi constructor(
     val consumers: List<Any>,
     val transform: (List<*>) -> R
 ) : Parser<R> {
 
-    fun process(tokens: Sequence<TokenMatch>): Pair<List<ParseResult<*>>, Sequence<TokenMatch>> {
+    private fun process(tokens: Sequence<TokenMatch>): Pair<List<ParseResult<*>>, Sequence<TokenMatch>> {
         var lastTokens = tokens
-        var errorResult: ErrorResult? = null
         return consumers.map { consumer ->
             val parser = when (consumer) {
                 is Parser<*> -> consumer
-                is SkipParser<*> -> consumer.innerParser
+                is SkipParser -> consumer.innerParser
                 else -> throw IllegalArgumentException()
             }
-            val result = errorResult ?: parser.tryParse(lastTokens)
+            val result = parser.tryParse(lastTokens)
             when (result) {
                 is ErrorResult -> return@process listOf(result) to lastTokens
                 is Parsed<*> -> lastTokens = result.remainder
             }
-            if (consumer is SkipParser<*>) null else result
+            if (consumer is SkipParser) null else result
         }.filterNotNull() to lastTokens
     }
 
@@ -47,25 +51,4 @@ class AndCombinator<out R : Tuple> internal @PublishedApi constructor(
         return results.firstOrNull { it is ErrorResult } as? ErrorResult
                ?: results.filterIsInstance<Parsed<*>>().let { Parsed(transform(it.map { it.value }), remainder) }
     }
-}
-
-/** Wraps a [Parser] to distinguish it from other parsers when it is used in [and] functions. */
-class SkipParser<T>(val innerParser: Parser<T>)
-
-/** Wraps a [Parser] to distinguish it from other parsers when it is used in [and] functions. */
-fun <T> skip(parser: Parser<T>) = SkipParser(parser)
-
-/** Parses the sequence with the receiver [Parser] and the wrapped [other] parser, but returns the [Parsed] result
- * from the receiver parser. */
-infix fun <T : Tuple, B> AndCombinator<T>.and(other: SkipParser<B>) =
-    AndCombinator(consumers + other, transform)
-
-/** Parses the sequence with the receiver [Parser] and the wrapped [other] parser, but returns the [Parsed] result
- * with a value from the receiver parser in a [Tuple1]. */
-infix inline fun <reified T> Parser<T>.and(other: SkipParser<*>) =
-    AndCombinator(listOf(this, other), { (a) -> Tuple1(a as T) })
-
-/** Parses the wrapped receiver [Parser] and the [other] parser and returns the [Parsed] result
- * with a value from the [other] parser in a [Tuple1]. */
-infix inline fun <reified T> SkipParser<*>.and(other: Parser<T>) =
-    AndCombinator(listOf(this, other)) { (b) -> Tuple1(b as T) }
+}

src/main/kotlin/com/github/h0tk3y/betterParse/combinators/SkipParser.kt

@@ -0,0 +1,46 @@
+package com.github.h0tk3y.betterParse.combinators
+
+import com.github.h0tk3y.betterParse.parser.Parsed
+import com.github.h0tk3y.betterParse.parser.Parser
+import com.github.h0tk3y.betterParse.utils.Tuple
+import com.github.h0tk3y.betterParse.utils.Tuple1
+
+/** Wraps a [Parser] to distinguish it from other parsers when it is used in [and] functions. */
+class SkipParser(val innerParser: Parser<*>)
+
+/** Wraps a [Parser] to distinguish it from other parsers when it is used in [and] functions. */
+fun <T> skip(parser: Parser<T>) = SkipParser(parser)
+
+/** The same as `[skip] of this parser. ` */
+operator fun Parser<*>.unaryMinus() = skip(this)
+
+/** Parses the sequence with the receiver [Parser] and the wrapped [other] parser, but returns the [Parsed] result
+ * from the receiver parser. */
+infix fun <T : Tuple> AndCombinator<T>.and(other: SkipParser) =
+    AndCombinator(consumers + other, transform)
+
+operator fun <T : Tuple> AndCombinator<T>.times(other: SkipParser) = this and other
+
+/** Parses the sequence with the receiver [Parser] and the wrapped [other] parser, but returns the [Parsed] result
+ * with a value from the receiver parser in a [Tuple1]. */
+infix inline fun <reified T> Parser<T>.and(other: SkipParser) =
+    AndCombinator(listOf(this, other), { (a) -> a as T } )
+
+/** The same as `this `[and]` other`*/
+operator inline fun <reified T> Parser<T>.times(other: SkipParser) = this and other
+
+/** Parses the wrapped receiver [Parser] and the [other] parser and returns the [Parsed] result
+ * with a value from the [other] parser in a [Tuple1]. */
+infix inline fun <reified T> SkipParser.and(other: Parser<T>) =
+    AndCombinator(listOf(this, other)) { (b) -> b as T }
+
+/** The same as `this `[and]` other`*/
+operator inline fun <reified T> SkipParser.times(other: Parser<T>) = this and other
+
+infix fun SkipParser.and(other: SkipParser): SkipParser {
+    val parsersLeft = if (innerParser is AndCombinator) innerParser.consumers else listOf(innerParser)
+    return SkipParser(AndCombinator(parsersLeft + other.innerParser, { Unit }))
+}
+
+/** The same as `this `[and]` other`*/
+operator fun SkipParser.times(other: SkipParser) = this and other