feat(core/Result): add doTry builder method and andThen right folding…

… method

src/commonMain/kotlin/com/liftric/cognito/idp/core/Result.kt

@@ -13,6 +13,16 @@ class Result<out T> constructor(val value: Any?) {
     companion object {
         fun <T> success(value: T): Result<T> = Result(value)
         fun <T> failure(exception: Throwable): Result<T> = Result(Failure(exception))
+
+        /**
+         * [Result] builder function. Returns Success if [mightFail] doesn't, otherwise returns
+         * [mightFail] exception as [Failure]
+         */
+        fun <T> doTry(mightFail: () -> T) : Result<T> = try {
+             success(mightFail())
+         } catch (e: Throwable){
+             failure(e)
+         }
     }
 
     class Failure(val exception: Throwable) {
@@ -54,6 +64,19 @@ class Result<out T> constructor(val value: Any?) {
         }
     }
 
+    /**
+     * Executes the [onSuccess] mapping if Success, or re-wraps the Failure doing nothing
+     *
+     * This can be used to pipe transform the result only if it is successful.
+     * A happy path of results can be modelled with this.
+     *
+     * Would be called foldRight if [Result] would be called Either<Throwable,T> ;)
+     */
+    fun <R> andThen(onSuccess: (value: T) -> R): Result<R> = when(value) {
+        is Failure -> failure(value.exception)
+        else -> doTry { onSuccess(value as T) }
+    }
+
     override fun toString(): String =
         when (value) {
             is Failure -> value.toString()
@@ -92,4 +115,4 @@ inline fun <T, R> T.runCatching(block: T.() -> R): Result<R> {
     } catch (e: Throwable) {
         Result.failure(e)
     }
-}
+}

src/commonTest/kotlin/com/liftric/cognito/idp/ResultTests.kt

@@ -65,6 +65,52 @@ class ResultTests {
         assertEquals(expected, result)
     }
 
+    @Test
+    fun testDoTryAndFold() {
+        Result.doTry { "1" }
+            .andThen { "${it}2" }
+            .andThen { it.toInt() }
+            .andThen { it * 2 }
+            .fold(onFailure = {fail("shouldn't fail!")}, onSuccess = { assertEquals(24, it) })
+    }
+
+    @Test
+    fun testAndThenOnSuccess() {
+        var result: String? = null
+        Result.success("Hans")
+            .andThen { "$it Wurst" }
+            .fold(
+                onSuccess = {
+                    result = it
+                },
+                onFailure = {
+                    fail("onFailure() should not get called")
+                }
+            )
+        assertEquals("Hans Wurst", result)
+    }
+
+    @Test
+    fun testAndThenOnFailure() {
+        val exception = Exception("firstException")
+        val failedAndThen = Result.failure<String>(exception)
+            .andThen {
+                Result.success("won't happen")
+            }
+
+        assertEquals(true, failedAndThen.isFailure)
+        assertEquals(exception, failedAndThen.exceptionOrNull())
+
+        Result.success("Test")
+            .andThen {
+                error("sad")
+            }.fold(onSuccess = {
+                fail("onSuccess() should not get called")
+            }, onFailure = {
+                assertEquals("sad" ,it.message)
+            })
+    }
+
     @Test
     fun testFoldOnFailure() {
         val expected = IOException("No connectivity")
@@ -115,4 +161,4 @@ class ResultTests {
         assertEquals(expected, result.exceptionOrNull())
         assertNull(result.getOrNull())
     }
-}
+}