Updated compose

sksamuel · Dec 30, 2023 · 5e8f1f8 · 5e8f1f8
1 parent 7207484
commit 5e8f1f8
Show file tree

Hide file tree

Showing 7 changed files with 322 additions and 231 deletions.
diff --git a/tribune-core/src/main/kotlin/com/sksamuel/tribune/core/compose.kt b/tribune-core/src/main/kotlin/com/sksamuel/tribune/core/compose.kt
@@ -13,87 +13,87 @@ fun <INPUT, OUTPUT, A, B, C, ERROR> Parser.Companion.compose(
    f: (A, B, C) -> OUTPUT,
 ): Parser<INPUT, OUTPUT, ERROR> = zip(p1, p2, p3).map { (a, b, c) -> f(a, b, c) }
 
-//fun <INPUT, OUTPUT, A, B, C, D, ERROR> Parser.Companion.compose(
-//   p1: Parser<INPUT, A, ERROR>,
-//   p2: Parser<INPUT, B, ERROR>,
-//   p3: Parser<INPUT, C, ERROR>,
-//   p4: Parser<INPUT, D, ERROR>,
-//   f: (A, B, C, D) -> OUTPUT,
-//): Parser<INPUT, OUTPUT, ERROR> = zip(p1, p2, p3, p4).map { (a, b, c, d) -> f(a, b, c, d) }
-//
-//fun <INPUT, OUTPUT, A, B, C, D, E, ERROR> Parser.Companion.compose(
-//   p1: Parser<INPUT, A, ERROR>,
-//   p2: Parser<INPUT, B, ERROR>,
-//   p3: Parser<INPUT, C, ERROR>,
-//   p4: Parser<INPUT, D, ERROR>,
-//   p5: Parser<INPUT, E, ERROR>,
-//   f: (A, B, C, D, E) -> OUTPUT,
-//): Parser<INPUT, OUTPUT, ERROR> = zip(p1, p2, p3, p4, p5).map { (a, b, c, d, e) -> f(a, b, c, d, e) }
-//
-//fun <INPUT, OUTPUT, A, B, C, D, E, F, ERROR> Parser.Companion.compose(
-//   p1: Parser<INPUT, A, ERROR>,
-//   p2: Parser<INPUT, B, ERROR>,
-//   p3: Parser<INPUT, C, ERROR>,
-//   p4: Parser<INPUT, D, ERROR>,
-//   p5: Parser<INPUT, E, ERROR>,
-//   p6: Parser<INPUT, F, ERROR>,
-//   f: (A, B, C, D, E, F) -> OUTPUT,
-//): Parser<INPUT, OUTPUT, ERROR> = zip(p1, p2, p3, p4, p5, p6).map { (a, b, c, d, e, f) -> f(a, b, c, d, e, f) }
-//
-//fun <INPUT, OUTPUT, A, B, C, D, E, F, G, ERROR> Parser.Companion.compose(
-//   p1: Parser<INPUT, A, ERROR>,
-//   p2: Parser<INPUT, B, ERROR>,
-//   p3: Parser<INPUT, C, ERROR>,
-//   p4: Parser<INPUT, D, ERROR>,
-//   p5: Parser<INPUT, E, ERROR>,
-//   p6: Parser<INPUT, F, ERROR>,
-//   p7: Parser<INPUT, G, ERROR>,
-//   f: (A, B, C, D, E, F, G) -> OUTPUT,
-//): Parser<INPUT, OUTPUT, ERROR> =
-//   zip(p1, p2, p3, p4, p5, p6, p7).map { (a, b, c, d, e, f, g) -> f(a, b, c, d, e, f, g) }
-//
-//fun <INPUT, OUTPUT, A, B, C, D, E, F, G, H, ERROR> Parser.Companion.compose(
-//   p1: Parser<INPUT, A, ERROR>,
-//   p2: Parser<INPUT, B, ERROR>,
-//   p3: Parser<INPUT, C, ERROR>,
-//   p4: Parser<INPUT, D, ERROR>,
-//   p5: Parser<INPUT, E, ERROR>,
-//   p6: Parser<INPUT, F, ERROR>,
-//   p7: Parser<INPUT, G, ERROR>,
-//   p8: Parser<INPUT, H, ERROR>,
-//   f: (A, B, C, D, E, F, G, H) -> OUTPUT,
-//): Parser<INPUT, OUTPUT, ERROR> =
-//   zip(p1, p2, p3, p4, p5, p6, p7, p8).map { (a, b, c, d, e, f, g, h) -> f(a, b, c, d, e, f, g, h) }
-//
-//fun <INPUT, OUTPUT, A, B, C, D, E, F, G, H, I, ERROR> Parser.Companion.compose(
-//   p1: Parser<INPUT, A, ERROR>,
-//   p2: Parser<INPUT, B, ERROR>,
-//   p3: Parser<INPUT, C, ERROR>,
-//   p4: Parser<INPUT, D, ERROR>,
-//   p5: Parser<INPUT, E, ERROR>,
-//   p6: Parser<INPUT, F, ERROR>,
-//   p7: Parser<INPUT, G, ERROR>,
-//   p8: Parser<INPUT, H, ERROR>,
-//   p9: Parser<INPUT, I, ERROR>,
-//   f: (A, B, C, D, E, F, G, H, I) -> OUTPUT,
-//): Parser<INPUT, OUTPUT, ERROR> =
-//   zip(p1, p2, p3, p4, p5, p6, p7, p8, p9).map { (a, b, c, d, e, f, g, h, i) ->
-//      f(a, b, c, d, e, f, g, h, i)
-//   }
-//
-//fun <INPUT, OUTPUT, A, B, C, D, E, F, G, H, I, J, ERROR> Parser.Companion.compose(
-//   p1: Parser<INPUT, A, ERROR>,
-//   p2: Parser<INPUT, B, ERROR>,
-//   p3: Parser<INPUT, C, ERROR>,
-//   p4: Parser<INPUT, D, ERROR>,
-//   p5: Parser<INPUT, E, ERROR>,
-//   p6: Parser<INPUT, F, ERROR>,
-//   p7: Parser<INPUT, G, ERROR>,
-//   p8: Parser<INPUT, H, ERROR>,
-//   p9: Parser<INPUT, I, ERROR>,
-//   p10: Parser<INPUT, J, ERROR>,
-//   f: (A, B, C, D, E, F, G, H, I, J) -> OUTPUT,
-//): Parser<INPUT, OUTPUT, ERROR> =
-//   zip(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10).map { (a, b, c, d, e, f, g, h, i, j) ->
-//      f(a, b, c, d, e, f, g, h, i, j)
-//   }
+fun <INPUT, OUTPUT, A, B, C, D, ERROR> Parser.Companion.compose(
+   p1: Parser<INPUT, A, ERROR>,
+   p2: Parser<INPUT, B, ERROR>,
+   p3: Parser<INPUT, C, ERROR>,
+   p4: Parser<INPUT, D, ERROR>,
+   f: (A, B, C, D) -> OUTPUT,
+): Parser<INPUT, OUTPUT, ERROR> = zip(p1, p2, p3, p4).map { (a, b, c, d) -> f(a, b, c, d) }
+
+fun <INPUT, OUTPUT, A, B, C, D, E, ERROR> Parser.Companion.compose(
+   p1: Parser<INPUT, A, ERROR>,
+   p2: Parser<INPUT, B, ERROR>,
+   p3: Parser<INPUT, C, ERROR>,
+   p4: Parser<INPUT, D, ERROR>,
+   p5: Parser<INPUT, E, ERROR>,
+   f: (A, B, C, D, E) -> OUTPUT,
+): Parser<INPUT, OUTPUT, ERROR> = zip(p1, p2, p3, p4, p5).map { (a, b, c, d, e) -> f(a, b, c, d, e) }
+
+fun <INPUT, OUTPUT, A, B, C, D, E, F, ERROR> Parser.Companion.compose(
+   p1: Parser<INPUT, A, ERROR>,
+   p2: Parser<INPUT, B, ERROR>,
+   p3: Parser<INPUT, C, ERROR>,
+   p4: Parser<INPUT, D, ERROR>,
+   p5: Parser<INPUT, E, ERROR>,
+   p6: Parser<INPUT, F, ERROR>,
+   f: (A, B, C, D, E, F) -> OUTPUT,
+): Parser<INPUT, OUTPUT, ERROR> = zip(p1, p2, p3, p4, p5, p6).map { (a, b, c, d, e, f) -> f(a, b, c, d, e, f) }
+
+fun <INPUT, OUTPUT, A, B, C, D, E, F, G, ERROR> Parser.Companion.compose(
+   p1: Parser<INPUT, A, ERROR>,
+   p2: Parser<INPUT, B, ERROR>,
+   p3: Parser<INPUT, C, ERROR>,
+   p4: Parser<INPUT, D, ERROR>,
+   p5: Parser<INPUT, E, ERROR>,
+   p6: Parser<INPUT, F, ERROR>,
+   p7: Parser<INPUT, G, ERROR>,
+   f: (A, B, C, D, E, F, G) -> OUTPUT,
+): Parser<INPUT, OUTPUT, ERROR> =
+   zip(p1, p2, p3, p4, p5, p6, p7).map { (a, b, c, d, e, f, g) -> f(a, b, c, d, e, f, g) }
+
+fun <INPUT, OUTPUT, A, B, C, D, E, F, G, H, ERROR> Parser.Companion.compose(
+   p1: Parser<INPUT, A, ERROR>,
+   p2: Parser<INPUT, B, ERROR>,
+   p3: Parser<INPUT, C, ERROR>,
+   p4: Parser<INPUT, D, ERROR>,
+   p5: Parser<INPUT, E, ERROR>,
+   p6: Parser<INPUT, F, ERROR>,
+   p7: Parser<INPUT, G, ERROR>,
+   p8: Parser<INPUT, H, ERROR>,
+   f: (A, B, C, D, E, F, G, H) -> OUTPUT,
+): Parser<INPUT, OUTPUT, ERROR> =
+   zip(p1, p2, p3, p4, p5, p6, p7, p8).map { (a, b, c, d, e, f, g, h) -> f(a, b, c, d, e, f, g, h) }
+
+fun <INPUT, OUTPUT, A, B, C, D, E, F, G, H, I, ERROR> Parser.Companion.compose(
+   p1: Parser<INPUT, A, ERROR>,
+   p2: Parser<INPUT, B, ERROR>,
+   p3: Parser<INPUT, C, ERROR>,
+   p4: Parser<INPUT, D, ERROR>,
+   p5: Parser<INPUT, E, ERROR>,
+   p6: Parser<INPUT, F, ERROR>,
+   p7: Parser<INPUT, G, ERROR>,
+   p8: Parser<INPUT, H, ERROR>,
+   p9: Parser<INPUT, I, ERROR>,
+   f: (A, B, C, D, E, F, G, H, I) -> OUTPUT,
+): Parser<INPUT, OUTPUT, ERROR> =
+   zip(p1, p2, p3, p4, p5, p6, p7, p8, p9).map { (a, b, c, d, e, f, g, h, i) ->
+      f(a, b, c, d, e, f, g, h, i)
+   }
+
+fun <INPUT, OUTPUT, A, B, C, D, E, F, G, H, I, J, ERROR> Parser.Companion.compose(
+   p1: Parser<INPUT, A, ERROR>,
+   p2: Parser<INPUT, B, ERROR>,
+   p3: Parser<INPUT, C, ERROR>,
+   p4: Parser<INPUT, D, ERROR>,
+   p5: Parser<INPUT, E, ERROR>,
+   p6: Parser<INPUT, F, ERROR>,
+   p7: Parser<INPUT, G, ERROR>,
+   p8: Parser<INPUT, H, ERROR>,
+   p9: Parser<INPUT, I, ERROR>,
+   p10: Parser<INPUT, J, ERROR>,
+   f: (A, B, C, D, E, F, G, H, I, J) -> OUTPUT,
+): Parser<INPUT, OUTPUT, ERROR> =
+   zip(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10).map { (a, b, c, d, e, f, g, h, i, j) ->
+      f(a, b, c, d, e, f, g, h, i, j)
+   }
diff --git a/tribune-core/src/main/kotlin/com/sksamuel/tribune/core/doubles/doubles.kt b/tribune-core/src/main/kotlin/com/sksamuel/tribune/core/doubles/doubles.kt
@@ -47,3 +47,7 @@ fun <I, E> Parser<I, Double, E>.inrange(
 
 fun <I, E> Parser<I, Double, E>.nullIf(fn: (Double) -> Boolean): Parser<I, Double?, E> =
    this.map { if (fn(it)) null else it }
+
+@JvmName("nullIfNullable")
+fun <I, E> Parser<I, Double?, E>.nullIf(fn: (Double) -> Boolean): Parser<I, Double?, E> =
+   this.map { if (it == null || fn(it)) null else it }
diff --git a/tribune-core/src/main/kotlin/com/sksamuel/tribune/core/ints/ints.kt b/tribune-core/src/main/kotlin/com/sksamuel/tribune/core/ints/ints.kt
@@ -45,6 +45,7 @@ fun <I, E> Parser<I, Int, E>.min(min: Int, ifError: (Int) -> E): Parser<I, Int,
       if (it >= min) it.right() else ifError(it).leftNel()
    }
 
+@JvmName("minOrNull")
 fun <I, E> Parser<I, Int?, E>.min(min: Int, ifError: (Int) -> E): Parser<I, Int?, E> =
    flatMap {
       if (it == null) Either.Right(null) else if (it >= min) it.right() else ifError(it).leftNel()
@@ -55,6 +56,7 @@ fun <I, E> Parser<I, Int, E>.max(min: Int, ifError: (Int) -> E): Parser<I, Int,
       if (it >= min) it.right() else ifError(it).leftNel()
    }
 
+@JvmName("maxOrNull")
 fun <I, E> Parser<I, Int?, E>.max(min: Int, ifError: (Int) -> E): Parser<I, Int?, E> =
    flatMap {
       if (it == null) Either.Right(null) else if (it >= min) it.right() else ifError(it).leftNel()
@@ -64,5 +66,5 @@ fun <I, E> Parser<I, Int, E>.nullIf(fn: (Int) -> Boolean): Parser<I, Int?, E> =
    this.map { if (fn(it)) null else it }
 
 @JvmName("nullIfNullable")
-fun <I, E> Parser<I, Long?, E>.nullIf(fn: (Long) -> Boolean): Parser<I, Long?, E> =
+fun <I, E> Parser<I, Int?, E>.nullIf(fn: (Int) -> Boolean): Parser<I, Int?, E> =
    this.map { if (it == null || fn(it)) null else it }
diff --git a/tribune-core/src/main/kotlin/com/sksamuel/tribune/core/parser.kt b/tribune-core/src/main/kotlin/com/sksamuel/tribune/core/parser.kt
@@ -9,7 +9,7 @@ import arrow.core.right
  *
  * It is implemented as an interface to allow for variance on the type parameters.
  */
-fun interface Parser<in I, out A, out E> {
+fun interface Parser<in I, out O, out E> {
 
    companion object {
 
@@ -36,13 +36,13 @@ fun interface Parser<in I, out A, out E> {
     * Parses the given [input] returning an either that contains the successfully parsed result
     * as a right, or a failure as a left.
     */
-   fun parse(input: I): EitherNel<E, A>
+   fun parse(input: I): EitherNel<E, O>
 
    /**
     * Returns a new Parser<J> that wraps this parser, by using the supplied function [f]
     * to convert a given [J] into an [I].
     */
-   fun <J> contramap(f: (J) -> I): Parser<J, A, E> =
+   fun <J> contramap(f: (J) -> I): Parser<J, O, E> =
       Parser { parse(f(it)) }
 
 }