Add arrow-kt Either to benchmarks

Closes #129

Author: alphaho

benchmarks/build.gradle.kts

@@ -23,6 +23,7 @@ kotlin {
                 implementation(project(":kotlin-result-coroutines"))
                 implementation(libs.kotlin.benchmark.runtime)
                 implementation(libs.kotlin.coroutines.core)
+                implementation(libs.arrow)
             }
         }
     }

benchmarks/src/commonMain/kotlin/com/github/michaelbull/result/BindingBenchmark.kt

@@ -1,5 +1,10 @@
 package com.github.michaelbull.result
 
+import arrow.core.raise.either
+import arrow.core.Either
+import arrow.core.flatMap
+import arrow.core.left
+import arrow.core.right
 import kotlinx.benchmark.Benchmark
 import kotlinx.benchmark.BenchmarkMode
 import kotlinx.benchmark.BenchmarkTimeUnit
@@ -36,6 +41,28 @@ class BindingBenchmark {
         blackhole.consume(result)
     }
 
+    @Benchmark
+    fun arrowBindingSuccess(blackhole: Blackhole) {
+        val result: Either<Error, Int> = either {
+            val x = arrowProvideX().bind()
+            val y = arrowProvideY().bind()
+            x + y
+        }
+
+        blackhole.consume(result)
+    }
+
+    @Benchmark
+    fun arrowBindingFailure(blackhole: Blackhole) {
+        val result: Either<Error, Int> = either {
+            val x = arrowProvideX().bind()
+            val z = arrowProvideZ().bind()
+            x + z
+        }
+
+        blackhole.consume(result)
+    }
+
     @Benchmark
     fun andThenSuccess(blackhole: Blackhole) {
         val result = provideX().andThen { x ->
@@ -58,9 +85,35 @@ class BindingBenchmark {
         blackhole.consume(result)
     }
 
+    @Benchmark
+    fun arrowFlatMapSuccess(blackhole: Blackhole) {
+        val result = arrowProvideX().flatMap { x ->
+            arrowProvideY().flatMap { y ->
+                (x + y).right()
+            }
+        }
+
+        blackhole.consume(result)
+    }
+
+    @Benchmark
+    fun arrowFlatMapFailure(blackhole: Blackhole) {
+        val result = arrowProvideX().flatMap { x ->
+            arrowProvideZ().flatMap { z ->
+                (x + z).right()
+            }
+        }
+
+        blackhole.consume(result)
+    }
+
     private object Error
 
     private fun provideX(): Result<Int, Error> = Ok(1)
     private fun provideY(): Result<Int, Error> = Ok(2)
     private fun provideZ(): Result<Int, Error> = Err(Error)
+
+    private fun arrowProvideX(): Either<Error, Int> = 1.right()
+    private fun arrowProvideY(): Either<Error, Int> = 2.right()
+    private fun arrowProvideZ(): Either<Error, Int> = Error.left()
 }

benchmarks/src/jvmMain/kotlin/com/github/michaelbull/result/CoroutineBindingBenchmark.kt

@@ -1,5 +1,8 @@
 package com.github.michaelbull.result
 
+import arrow.core.Either
+import arrow.core.raise.either
+import arrow.core.right
 import com.github.michaelbull.result.coroutines.coroutineBinding
 import kotlinx.benchmark.Benchmark
 import kotlinx.benchmark.BenchmarkMode
@@ -10,6 +13,7 @@ import kotlinx.benchmark.OutputTimeUnit
 import kotlinx.benchmark.Scope
 import kotlinx.benchmark.State
 import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
 
@@ -37,6 +41,25 @@ class CoroutineBindingBenchmark {
         }
     }
 
+    @Benchmark
+    fun arrowNonSuspendableBinding(blackhole: Blackhole) {
+        blackhole.consume(nonSuspend().get())
+    }
+
+    @Benchmark
+    fun arrowSuspendableBinding(blackhole: Blackhole) {
+        runBlocking {
+            blackhole.consume(withSuspend().get())
+        }
+    }
+
+    @Benchmark
+    fun arrowAsyncSuspendableBinding(blackhole: Blackhole) {
+        runBlocking {
+            blackhole.consume(withAsyncSuspend().get())
+        }
+    }
+
     private object Error
 
     private val time = 100L
@@ -78,4 +101,44 @@ class CoroutineBindingBenchmark {
         delay(time)
         return Ok(2)
     }
+
+    private fun arrowNonSuspend(): Either<Error, Int> = either {
+        val x = arrowProvideXBlocking().bind()
+        val y = arrowProvideYBlocking().bind()
+        x + y
+    }
+
+    private suspend fun arrowWithSuspend(): Either<Error, Int> = either {
+        val x = arrowProvideX().bind()
+        val y = arrowProvideY().bind()
+        x + y
+    }
+
+    private suspend fun arrowWithAsyncSuspend(): Either<Error, Int> = either {
+        coroutineScope {
+            val x = async { arrowProvideX().bind() }
+            val y = async { arrowProvideY().bind() }
+            x.await() + y.await()
+        }
+    }
+
+    private fun arrowProvideXBlocking(): Either<Error, Int> {
+        Thread.sleep(time)
+        return 1.right()
+    }
+
+    private fun arrowProvideYBlocking(): Either<Error, Int> {
+        Thread.sleep(time)
+        return 2.right()
+    }
+
+    private suspend fun arrowProvideX(): Either<Error, Int> {
+        delay(time)
+        return 1.right()
+    }
+
+    private suspend fun arrowProvideY(): Either<Error, Int> {
+        delay(time)
+        return 2.right()
+    }
 }

gradle/libs.versions.toml

@@ -6,20 +6,24 @@ maven-publish-plugin = "0.34.0"
 
 # benchmarks subproject
 kotlin-benchmark = "0.4.14"
+arrow = "2.1.2"
 
 # example subproject
 ktor = "3.2.3"
 logback = "1.5.18"
 
 
 [libraries]
-kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
 kotlin-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines" }
 kotlin-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlin-coroutines" }
+
+# buildSrc subproject
+kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
 maven-publish-plugin = { module = "com.vanniktech.maven.publish:com.vanniktech.maven.publish.gradle.plugin", version.ref = "maven-publish-plugin" }
 
 # benchmarks subproject
 kotlin-benchmark-runtime = { module = "org.jetbrains.kotlinx:kotlinx-benchmark-runtime", version.ref = "kotlin-benchmark" }
+arrow = { module = "io.arrow-kt:arrow-core", version.ref = "arrow" }
 
 # example subproject
 kotlin-stdlib-jdk8 = { module = "org.jetbrains.kotlin:kotlin-stdlib-jdk8", version.ref = "kotlin" }
@@ -29,10 +33,9 @@ ktor-server-content-negotiation = { module = "io.ktor:ktor-server-content-negoti
 ktor-server-netty = { module = "io.ktor:ktor-server-netty", version.ref = "ktor" }
 logback = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
 
-
 [plugins]
 versions = { id = "com.github.ben-manes.versions", version.ref = "versions-plugin" }
 
-# benchmarks
+# benchmarks subproject
 kotlin-allopen = { id = "org.jetbrains.kotlin.plugin.allopen", version.ref = "kotlin" }
 kotlin-benchmark = { id = "org.jetbrains.kotlinx.benchmark", version.ref = "kotlin-benchmark" }