arrow 2.0.0

Author: hoc081098

build.gradle.kts

@@ -67,10 +67,11 @@ dependencies {
   implementation("com.ensody.reactivestate:reactivestate")
 
   // Arrow-kt
-  val arrow = "1.2.4"
+  val arrow = "2.0.0"
   implementation("io.arrow-kt:arrow-core:$arrow")
   implementation("io.arrow-kt:arrow-fx-coroutines:$arrow")
   implementation("io.arrow-kt:arrow-autoclose:$arrow")
+  implementation("io.arrow-kt:arrow-resilience:$arrow")
 }
 
 tasks.test {

src/main/kotlin/com/hoc081098/kotlin_playground/arrowkt/Schedule-recurs.kt

@@ -0,0 +1,14 @@
+package com.hoc081098.kotlin_playground.arrowkt
+
+import arrow.resilience.Schedule
+import arrow.resilience.retry
+import kotlinx.coroutines.runBlocking
+
+fun main(): Unit = runBlocking {
+  val recurs: Schedule<Throwable, Long> = Schedule.recurs<Throwable>(3)
+
+  recurs.retry {
+    println(">>> calling...")
+    throw RuntimeException("Error")
+  }
+}

src/main/kotlin/com/hoc081098/kotlin_playground/arrowkt/circuit_breaker.kt

@@ -0,0 +1,41 @@
+package com.hoc081098.kotlin_playground.arrowkt
+
+import arrow.core.Either
+import arrow.resilience.CircuitBreaker
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.ExperimentalTime
+import kotlinx.coroutines.delay
+
+@ExperimentalTime
+suspend fun main(): Unit {
+  val circuitBreaker = CircuitBreaker(
+    openingStrategy = CircuitBreaker.OpeningStrategy.Count(2),
+    resetTimeout = 2.seconds,
+    exponentialBackoffFactor = 1.2,
+    maxResetTimeout = 60.seconds,
+  )
+
+  // normal operation
+  circuitBreaker.protectOrThrow { "I am in Closed: ${circuitBreaker.state()}" }.also(::println)
+
+  // simulate service getting overloaded
+  Either.catch {
+    circuitBreaker.protectOrThrow { throw RuntimeException("Service overloaded") }
+  }.also(::println)
+  Either.catch {
+    circuitBreaker.protectOrThrow { throw RuntimeException("Service overloaded") }
+  }.also(::println)
+  circuitBreaker.protectEither { }
+    .also { println("I am Open and short-circuit with ${it}. ${circuitBreaker.state()}") }
+
+  println(">>> state should be Open: ${circuitBreaker.state()}")
+  // simulate reset timeout
+  println("Service recovering . . .").also { delay(2500) }
+  println(">>> state should be HalfOpen: ${circuitBreaker.state()}")
+
+  // simulate test request success
+  circuitBreaker.protectOrThrow {
+    "I am running test-request in HalfOpen: ${circuitBreaker.state()}"
+  }.also(::println)
+  println("I am back to normal state closed ${circuitBreaker.state()}")
+}

src/main/kotlin/com/hoc081098/kotlin_playground/arrowkt/circuit_breaker_schedule.kt

@@ -0,0 +1,54 @@
+package com.hoc081098.kotlin_playground.arrowkt
+
+import arrow.core.Either
+import arrow.resilience.CircuitBreaker
+import arrow.resilience.Schedule
+import arrow.resilience.retry
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.ExperimentalTime
+import kotlinx.coroutines.delay
+
+@ExperimentalTime
+suspend fun main(): Unit {
+  suspend fun apiCall(): Unit {
+    println("apiCall . . .")
+    delay(100)
+    throw RuntimeException("Overloaded service")
+  }
+
+  val circuitBreaker = CircuitBreaker(
+    openingStrategy = CircuitBreaker.OpeningStrategy.Count(2),
+    resetTimeout = 2.seconds,
+    exponentialBackoffFactor = 1.2,
+    maxResetTimeout = 60.seconds,
+  )
+
+  suspend fun <A> resilient(schedule: Schedule<Throwable, *>, f: suspend () -> A): A =
+    schedule.retry {
+      println(">>> retry...")
+      circuitBreaker.protectOrThrow {
+        println(">>> inside protectOrThrow")
+        f()
+      }
+    }
+
+  // simulate getting overloaded
+  Either.catch {
+    resilient(Schedule.recurs(5), ::apiCall)
+  }.let { println("recurs(5) apiCall twice and 4x short-circuit result from CircuitBreaker: $it") }
+
+  // simulate reset timeout
+  delay(2000)
+  println("CircuitBreaker ready to half-open")
+
+  // retry once,
+  // and when the CircuitBreaker opens after 2 failures
+  //    retry with exponential back-off with same time as CircuitBreaker's resetTimeout
+  val fiveTimesWithBackOff = Schedule.recurs<Throwable>(1)
+    .andThen(Schedule.exponential(2.seconds))
+    .and(Schedule.recurs(5))
+
+  Either.catch {
+    resilient(fiveTimesWithBackOff, ::apiCall)
+  }.let { println("exponential(2.seconds) and recurs(5) always retries with actual apiCall: $it") }
+}

src/main/kotlin/com/hoc081098/kotlin_playground/arrowkt/resource.kt

@@ -3,6 +3,7 @@ package com.hoc081098.kotlin_playground.arrowkt
 import arrow.fx.coroutines.asFlow
 import arrow.fx.coroutines.resource
 import arrow.fx.coroutines.resourceScope
+import arrow.fx.coroutines.use
 import com.hoc081098.solivagant.lifecycle.LenientLifecycleRegistry
 import com.hoc081098.solivagant.lifecycle.Lifecycle
 import kotlinx.coroutines.delay

src/main/kotlin/com/hoc081098/state/stateIn.kt

@@ -1,6 +1,5 @@
 package com.hoc081098.state
 
-import arrow.fx.coroutines.continuations.resource
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
@@ -40,4 +39,4 @@ fun main() = runBlocking {
         .launchIn(scope)
 
     delay(2000)
-}
+}