Kotlin promises composition:

commit 605b36e
Author: Tiago de Freitas Lima <[email protected]>
Date:   Mon May 23 10:28:00 2022 -0300

    (wip)

Author: ljtfreitas

kotlin/src/main/kotlin/com/github/ljtfreitas/julian/k/Extensions.kt

@@ -29,13 +29,22 @@ fun <T> Attempt<T>.result() : Result<T> = fold(Result.Companion::success, Result
 
 fun <T> Promise<T>.result() : Result<T> = join().result()
 
-operator fun Promise<out Any>.plus(other: Promise<out Any>): Promise<Array<Any?>> = bind { a ->
-    other.bind { b ->
-        Promise.done(when {
-            a is Array<*> && b is Array<*> -> arrayOf(*a, *b)
-            a is Array<*> -> arrayOf(*a, b)
-            b is Array<*> -> arrayOf(a, *b)
-            else -> arrayOf(a, b)
-        })
-    }
-}
+@JvmName("promisePlus")
+operator fun <A, B> Promise<A>.plus(other: Promise<B>): Promise<Pair<A, B>> = bind { a ->
+    other.then { b -> a to b }
+}
+
+@JvmName("promisePairPlus")
+operator fun <A, B, C> Promise<Pair<A, B>>.plus(other: Promise<C>): Promise<Triple<A, B, C>> = bind { (a, b) ->
+    other.then { c -> Triple(a, b, c) }
+}
+
+@JvmName("promiseTriplePlus")
+operator fun <A, B, C> Promise<Triple<A, B, C>>.plus(other: Promise<*>): Promise<Array<*>> = bind { (a, b, c) ->
+    other.then { d -> arrayOf(a, b, c, d) }
+}
+
+@JvmName("promiseArrayPlus")
+operator fun Promise<Array<*>>.plus(other: Promise<*>): Promise<Array<*>> = bind { a ->
+    other.then { b -> arrayOf(a, b) }
+}

kotlin/src/test/kotlin/com/github/ljtfreitas/julian/k/ExtensionsTest.kt

@@ -30,25 +30,80 @@ class ExtensionsTest : DescribeSpec({
 
             describe("composed Promises") {
 
-                it("composed, dependent successful Promises") {
+                it("a composition from two Promises should return a Pair") {
+                    val one = Promise.done("one")
+                    val two = Promise.done("two")
+
+                    val composed = one + two
+
+                    val pair: Pair<String, String> = composed.join().unsafe()
+
+                    val (a, b) = pair
+
+                    a shouldBe "one"
+                    b shouldBe "two"
+                }
+
+                it("a composition from three Promises should return a Triple") {
                     val one = Promise.done("one")
                     val two = Promise.done("two")
                     val three = Promise.done("three")
 
                     val composed = one + two + three
 
-                    val (a, b, c) = composed.join().unsafe()
+                    val triple: Triple<String, String, String> = composed.join().unsafe()
+
+                    val (a, b, c) = triple
+
+                    a shouldBe "one"
+                    b shouldBe "two"
+                    c shouldBe "three"
+                }
+
+                it("a composition from four Promises should return an Array") {
+                    val one = Promise.done("one")
+                    val two = Promise.done("two")
+                    val three = Promise.done("three")
+                    val four = Promise.done("four")
+
+                    val composed = one + two + three + four
+
+                    val array: Array<*> = composed.join().unsafe()
+
+                    val (a, b, c, d) = array
+
+                    a shouldBe "one"
+                    b shouldBe "two"
+                    c shouldBe "three"
+                    d shouldBe "four"
+                }
+
+                it("a composition from five (or more) Promises should return an Array as well") {
+                    val one = Promise.done("one")
+                    val two = Promise.done("two")
+                    val three = Promise.done("three")
+                    val four = Promise.done("four")
+                    val five = Promise.done("five")
+
+                    val composed = one + two + three + four + five
+
+                    val array: Array<*> = composed.join().unsafe()
+
+                    val (a, b, c, d, e) = array
 
                     a shouldBe "one"
                     b shouldBe "two"
                     c shouldBe "three"
+                    d shouldBe "four"
+                    e shouldBe "five"
                 }
 
                 it("a failed Promise should break composition") {
                     val failure = RuntimeException("i'm failed...")
 
                     val one = Promise.done("one")
                     val two = Promise.done("two")
+
                     val three = Promise.failed<String, RuntimeException>(failure)
 
                     val composed = one + two + three