From 4b0edacd48b041f379853f43f2c4a9989d68a428 Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Wed, 14 Dec 2022 14:04:38 +0100
Subject: [PATCH 01/15] Track if shift leaks outside of scope, and raise a
 different exception

---
 .../arrow/core/continuations/EagerEffect.kt   | 16 ++--
 .../kotlin/arrow/core/continuations/Effect.kt | 73 ++++++++++++-------
 .../core/continuations/EagerEffectSpec.kt     |  9 +++
 .../arrow/core/continuations/EffectSpec.kt    | 30 +++++---
 4 files changed, 87 insertions(+), 41 deletions(-)

diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/EagerEffect.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/EagerEffect.kt
index e5a7269cb54..c86e54bd075 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/EagerEffect.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/EagerEffect.kt
@@ -166,6 +166,7 @@ public fun <R, A> eagerEffect(f: suspend EagerEffectScope<R>.() -> A): EagerEffe
 private class DefaultEagerEffect<R, A>(private val f: suspend EagerEffectScope<R>.() -> A) : EagerEffect<R, A> {
   override fun <B> fold(recover: (R) -> B, transform: (A) -> B): B {
     val token = Token()
+    val isActive = AtomicRef(true)
     val eagerEffectScope =
       object : EagerEffectScope<R> {
         // Shift away from this Continuation by intercepting it, and completing it with
@@ -180,12 +181,15 @@ private class DefaultEagerEffect<R, A>(private val f: suspend EagerEffectScope<R
         // CancellationException and thus effectively recovering from the cancellation/shift.
         // This means try/catch is also capable of recovering from monadic errors.
           // See: EagerEffectSpec - try/catch tests
-          throw Eager(token, r, recover as (Any?) -> Any?)
+          if (isActive.get()) throw Eager(token, r, recover as (Any?) -> Any?)
+          else throw ShiftLeakedException()
       }
 
     return try {
-      suspend { transform(f(eagerEffectScope)) }
-        .startCoroutineUninterceptedOrReturn(Continuation(EmptyCoroutineContext) { result ->
+      suspend {
+        val res = f(eagerEffectScope).also { isActive.set(false) }
+        transform(res)
+      }.startCoroutineUninterceptedOrReturn(Continuation(EmptyCoroutineContext) { result ->
           result.getOrElse { throwable ->
             if (throwable is Eager && token == throwable.token) {
               throwable.recover(throwable.shifted) as B
@@ -193,8 +197,10 @@ private class DefaultEagerEffect<R, A>(private val f: suspend EagerEffectScope<R
           }
         }) as B
     } catch (e: Eager) {
-      if (token == e.token) e.recover(e.shifted) as B
-      else throw e
+      if (token == e.token) {
+        isActive.set(false)
+        e.recover(e.shifted) as B
+      } else throw e
     }
   }
 }
diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
index 84e55d1f9d6..a0147b7a179 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
@@ -26,19 +26,19 @@ import kotlin.coroutines.resumeWithException
  *
  * <!--- TOC -->
 
-      * [Writing a program with Effect<R, A>](#writing-a-program-with-effect<r-a>)
-      * [Handling errors](#handling-errors)
-      * [Structured Concurrency](#structured-concurrency)
-        * [Arrow Fx Coroutines](#arrow-fx-coroutines)
-          * [parZip](#parzip)
-          * [parTraverse](#partraverse)
-          * [raceN](#racen)
-          * [bracketCase / Resource](#bracketcase--resource)
-        * [KotlinX](#kotlinx)
-          * [withContext](#withcontext)
-          * [async](#async)
-          * [launch](#launch)
-          * [Strange edge cases](#strange-edge-cases)
+ * [Writing a program with Effect<R, A>](#writing-a-program-with-effect<r-a>)
+ * [Handling errors](#handling-errors)
+ * [Structured Concurrency](#structured-concurrency)
+ * [Arrow Fx Coroutines](#arrow-fx-coroutines)
+ * [parZip](#parzip)
+ * [parTraverse](#partraverse)
+ * [raceN](#racen)
+ * [bracketCase / Resource](#bracketcase--resource)
+ * [KotlinX](#kotlinx)
+ * [withContext](#withcontext)
+ * [async](#async)
+ * [launch](#launch)
+ * [Strange edge cases](#strange-edge-cases)
 
  * <!--- END -->
  *
@@ -716,7 +716,7 @@ internal class FoldContinuation<R, B>(
   private val error: suspend (Throwable) -> B,
   private val parent: Continuation<B>,
 ) : Continuation<B>, Token(), EffectScope<R> {
-  
+
   constructor(ignored: Token, context: CoroutineContext, parent: Continuation<B>) : this(context, { throw it }, parent)
   constructor(
     ignored: Token,
@@ -724,9 +724,12 @@ internal class FoldContinuation<R, B>(
     error: suspend (Throwable) -> B,
     parent: Continuation<B>,
   ) : this(context, error, parent)
-  
+
   lateinit var recover: suspend (R) -> Any?
-  
+
+  // Add AtomicBoolean to arrow-atomic
+  val isActive: AtomicRef<Boolean> = AtomicRef(true)
+
   // Shift away from this Continuation by intercepting it, and completing it with
   // ShiftCancellationException
   // This is needed because this function will never yield a result,
@@ -739,8 +742,9 @@ internal class FoldContinuation<R, B>(
   // CancellationException and thus effectively recovering from the cancellation/shift.
   // This means try/catch is also capable of recovering from monadic errors.
     // See: EffectSpec - try/catch tests
-    throw Suspend(this, r, recover as suspend (Any?) -> Any?)
-  
+    if (isActive.get()) throw Suspend(this, r, recover as suspend (Any?) -> Any?)
+    else throw ShiftLeakedException()
+
   // In contrast to `createCoroutineUnintercepted this doesn't create a new ContinuationImpl
   private fun (suspend () -> B).startCoroutineUnintercepted() {
     try {
@@ -753,15 +757,20 @@ internal class FoldContinuation<R, B>(
       parent.resumeWithException(e)
     }
   }
-  
+
   override fun resumeWith(result: Result<B>) {
     result.fold(parent::resume) { throwable ->
       when {
-        throwable is Suspend && this === throwable.token ->
+        throwable is Suspend && this === throwable.token -> {
+          isActive.set(false)
           suspend { throwable.recover(throwable.shifted) as B }.startCoroutineUnintercepted()
-        
+        }
+
         throwable is Suspend -> parent.resumeWith(result)
-        else -> suspend { error(throwable.nonFatalOrThrow()) }.startCoroutineUnintercepted()
+        else -> {
+          isActive.set(false)
+          suspend { error(throwable.nonFatalOrThrow()) }.startCoroutineUnintercepted()
+        }
       }
     }
   }
@@ -800,12 +809,12 @@ internal class FoldContinuation<R, B>(
 public fun <R, A> effect(f: suspend EffectScope<R>.() -> A): Effect<R, A> = DefaultEffect(f)
 
 private class DefaultEffect<R, A>(val f: suspend EffectScope<R>.() -> A) : Effect<R, A> {
-  
+
   override suspend fun <B> fold(
     recover: suspend (shifted: R) -> B,
     transform: suspend (value: A) -> B,
   ): B = fold({ throw it }, recover, transform)
-  
+
   // We create a `Token` for fold Continuation, so we can properly differentiate between nested folds
   override suspend fun <B> fold(
     error: suspend (error: Throwable) -> B,
@@ -816,14 +825,19 @@ private class DefaultEffect<R, A>(val f: suspend EffectScope<R>.() -> A) : Effec
       val shift = FoldContinuation<R, B>(cont.context, error, cont)
       shift.recover = recover
       try {
-        val fold: suspend EffectScope<R>.() -> B = { transform(f(this)) }
+        val fold: suspend EffectScope<R>.() -> B = {
+          val res = f(this).also { shift.isActive.set(false) }
+          transform(res)
+        }
         fold.startCoroutineUninterceptedOrReturn(shift, shift)
       } catch (e: Suspend) {
         if (shift === e.token) {
+          shift.isActive.set(false)
           val f: suspend () -> B = { e.recover(e.shifted) as B }
           f.startCoroutineUninterceptedOrReturn(cont)
         } else throw e
       } catch (e: Throwable) {
+        shift.isActive.set(false)
         val f: suspend () -> B = { error(e.nonFatalOrThrow()) }
         f.startCoroutineUninterceptedOrReturn(cont)
       }
@@ -831,3 +845,12 @@ private class DefaultEffect<R, A>(val f: suspend EffectScope<R>.() -> A) : Effec
 }
 
 public suspend fun <A> Effect<A, A>.merge(): A = fold(::identity, ::identity)
+
+public class ShiftLeakedException : RuntimeException(
+  """
+      "shift or bind occurred outside of its DSL scope, and the DSL scoped operator was leaked, this is kind of usage is incorrect.
+       Make sure all calls to shift or bind occur within the lifecycle of effect { }, either { } or similar.
+       
+       See: ... for additional information.
+    """.trimIndent()
+)
diff --git a/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/EagerEffectSpec.kt b/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/EagerEffectSpec.kt
index 7c32aeae4c4..fbe5a9ce49b 100644
--- a/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/EagerEffectSpec.kt
+++ b/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/EagerEffectSpec.kt
@@ -5,6 +5,7 @@ import arrow.core.identity
 import arrow.core.left
 import arrow.core.right
 import io.kotest.assertions.fail
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.shouldBe
 import io.kotest.property.Arb
@@ -134,4 +135,12 @@ class EagerEffectSpec : StringSpec({
       }.runCont()
     } shouldBe Either.Left(e)
   }
+
+  "shift leaked results in ShiftLeakException" {
+    shouldThrow<ShiftLeakedException> {
+      effect {
+        suspend { shift<Unit>("failure") }
+      }.fold(::println) { it.invoke() }
+    }
+  }
 })
diff --git a/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/EffectSpec.kt b/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/EffectSpec.kt
index af23c30c529..7cbe2d01f0a 100644
--- a/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/EffectSpec.kt
+++ b/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/EffectSpec.kt
@@ -272,14 +272,14 @@ class EffectSpec :
         }.runCont()
       } shouldBe Either.Left(e)
     }
-    
+
     "#2760 - dispatching in nested Effect blocks does not make the nested Continuation to hang" {
       checkAll(Arb.string()) { msg ->
         fun failure(): Effect<Failure, String> = effect {
           withContext(Dispatchers.Default) {}
           shift(Failure(msg))
         }
-        
+
         effect<Failure, Int> {
           failure().bind()
           1
@@ -289,30 +289,30 @@ class EffectSpec :
         ) shouldBe Failure(msg)
       }
     }
-  
+
     "#2779 - handleErrorWith does not make nested Continuations hang" {
       checkAll(Arb.string()) { error ->
         val failed: Effect<String, Int> = effect {
           withContext(Dispatchers.Default) {}
           shift(error)
         }
-      
+
         val newError: Effect<List<Char>, Int> =
           failed.handleErrorWith { str ->
             effect { shift(str.reversed().toList()) }
           }
-      
+
         newError.toEither() shouldBe Either.Left(error.reversed().toList())
       }
     }
-    
+
     "#2779 - bind nested in fold does not make nested Continuations hang" {
       checkAll(Arb.string()) { error ->
         val failed: Effect<String, Int> = effect {
           withContext(Dispatchers.Default) {}
           shift(error)
         }
-      
+
         val newError: Effect<List<Char>, Int> =
           effect {
             failed.fold({ r ->
@@ -321,11 +321,11 @@ class EffectSpec :
               }.bind()
             }, ::identity)
           }
-      
+
         newError.toEither() shouldBe Either.Left(error.reversed().toList())
       }
     }
-    
+
     "Can handle thrown exceptions" {
       checkAll(Arb.string().suspend(), Arb.string().suspend()) { msg, fallback ->
         effect<Int, String> {
@@ -337,7 +337,7 @@ class EffectSpec :
         ) shouldBe fallback()
       }
     }
-    
+
     "Can shift from thrown exceptions" {
       checkAll(Arb.string().suspend(), Arb.string().suspend()) { msg, fallback ->
         effect<String, Int> {
@@ -351,7 +351,7 @@ class EffectSpec :
         }.runCont() shouldBe fallback()
       }
     }
-  
+
     "Can throw from thrown exceptions" {
       checkAll(Arb.string().suspend(), Arb.string().suspend()) { msg, fallback ->
         shouldThrow<IllegalStateException> {
@@ -365,6 +365,14 @@ class EffectSpec :
         }.message shouldBe fallback()
       }
     }
+
+    "shift leaked results in ShiftLeakException" {
+      shouldThrow<ShiftLeakedException> {
+        effect {
+          suspend { shift<Unit>("failure") }
+        }.fold(::println) { f -> f() }
+      }
+    }
   })
 
 private data class Failure(val msg: String)

From ed794228aad51b9879f7afec72e8c9664eee9da4 Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Tue, 3 Jan 2023 14:46:28 +0100
Subject: [PATCH 02/15] Update docs

---
 .../kotlin/arrow/core/continuations/Effect.kt | 143 +++++++++++++-----
 .../examples/example-effect-guide-11.kt       |   8 +-
 .../examples/example-effect-guide-12.kt       |   5 +-
 .../examples/example-effect-guide-13.kt       |  13 --
 .../examples/example-effect-guide-14.kt       |  22 +++
 5 files changed, 134 insertions(+), 57 deletions(-)
 create mode 100644 arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-14.kt

diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
index a0147b7a179..7fd964c4d81 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
@@ -26,19 +26,19 @@ import kotlin.coroutines.resumeWithException
  *
  * <!--- TOC -->
 
- * [Writing a program with Effect<R, A>](#writing-a-program-with-effect<r-a>)
- * [Handling errors](#handling-errors)
- * [Structured Concurrency](#structured-concurrency)
- * [Arrow Fx Coroutines](#arrow-fx-coroutines)
- * [parZip](#parzip)
- * [parTraverse](#partraverse)
- * [raceN](#racen)
- * [bracketCase / Resource](#bracketcase--resource)
- * [KotlinX](#kotlinx)
- * [withContext](#withcontext)
- * [async](#async)
- * [launch](#launch)
- * [Strange edge cases](#strange-edge-cases)
+      * [Writing a program with Effect<R, A>](#writing-a-program-with-effect<r-a>)
+      * [Handling errors](#handling-errors)
+      * [Structured Concurrency](#structured-concurrency)
+        * [Arrow Fx Coroutines](#arrow-fx-coroutines)
+          * [parZip](#parzip)
+          * [parTraverse](#partraverse)
+          * [raceN](#racen)
+          * [bracketCase / Resource](#bracketcase--resource)
+        * [KotlinX](#kotlinx)
+          * [withContext](#withcontext)
+          * [async](#async)
+          * [launch](#launch)
+          * [Leaking `shift`](#leaking-shift)
 
  * <!--- END -->
  *
@@ -418,7 +418,7 @@ import kotlin.coroutines.resumeWithException
  *
  * ### KotlinX
  * #### withContext
- * It's always safe to call `shift` from `withContext` since it runs in place, so it has no way of leaking `shift`.
+ * It's always safe to call `shift` from `withContext` since it runs _in place_, so it has no way of leaking `shift`.
  * When `shift` is called from within `withContext` it will cancel all `Job`s running inside the `CoroutineScope` of `withContext`.
  *
  * <!--- INCLUDE
@@ -483,6 +483,8 @@ import kotlin.coroutines.resumeWithException
  * #### async
  *
  * When calling `shift` from `async` you should **always** call `await`, otherwise `shift` can leak out of its scope.
+ * So it's safe to call `shift` from `async` as long as you **always** call `await` on the `Deferred` returned by `async`,
+ * but we advise using Arrow Fx `parZip`, `raceN`, `parTraverse`, etc instead.
  *
  * <!--- INCLUDE
  * import arrow.core.continuations.effect
@@ -500,14 +502,29 @@ import kotlin.coroutines.resumeWithException
  *       val fa = async<Int> { shift(errorA) }
  *       val fb = async<Int> { shift(errorB) }
  *       fa.await() + fb.await()
- *     }.fold({ error -> error shouldBeIn listOf(errorA, errorB) }, { fail("Int can never be the result") })
+ *     }.fold(
+ *       { error ->
+ *         println(error)
+ *         error shouldBeIn listOf(errorA, errorB)
+ *       },
+ *       { fail("Int can never be the result") }
+ *     )
  *   }
  * }
  * ```
  * <!--- KNIT example-effect-guide-11.kt -->
+ * ```text
+ * ErrorA
+ * ```
+ *
+ * The example here will always print `ErrorA`, but never `ErrorB`. This is because `fa` is awaited first, and when it's `shifts` it will cancel `fb`.
+ * If instead we used `awaitAll`, then it would print `ErrorA` or `ErrorB` due to both `fa` and `fb` being awaited in parallel.
  *
  * #### launch
  *
+ * It's **not allowed** to call `shift` from within `launch`, this is because `launch` creates a separate process.
+ * Any calls to `shift` inside of `launch` will be ignored by `effect`, and result in an exception being thrown.
+ *
  * <!--- INCLUDE
  * import arrow.core.continuations.effect
  * import io.kotest.assertions.fail
@@ -519,29 +536,30 @@ import kotlin.coroutines.resumeWithException
  * suspend fun main() {
  *   val errorA = "ErrorA"
  *   val errorB = "ErrorB"
- *   val int = 45
  *   effect<String, Int> {
  *     coroutineScope<Int> {
  *       launch { shift(errorA) }
  *       launch { shift(errorB) }
- *       int
+ *       45
  *     }
- *   }.fold({ fail("Shift can never finish") }, { it shouldBe int })
+ *   }.fold({ fail("Shift can never finish") }, ::println)
  * }
  * ```
  * <!--- KNIT example-effect-guide-12.kt -->
+ * ```text
+ * 45
+ * ```
+ *
+ * As you can see from the output, the `effect` block is still executed, but the `shift` calls inside `launch` are ignored.
  *
- * #### Strange edge cases
+ * #### Leaking `shift`
  *
- * **NOTE**
- * Capturing `shift` into a lambda, and leaking it outside of `Effect` to be invoked outside will yield unexpected results.
- * Below we capture `shift` from inside the DSL, and then invoke it outside its context `EffectScope<String>`.
+ * **IMPORTANT:** Capturing `shift` and leaking it outside of `effect { }` and invoking it outside its scope will yield unexpected results.
+ *
+ * Below an example of the capturing of `shift` inside a `suspend lambda`, and then invoking it outside its `effect { }` scope.
  *
  * <!--- INCLUDE
  * import arrow.core.continuations.effect
- * import kotlinx.coroutines.Deferred
- * import kotlinx.coroutines.async
- * import kotlinx.coroutines.coroutineScope
  *
  * suspend fun main() {
  * -->
@@ -553,21 +571,65 @@ import kotlin.coroutines.resumeWithException
  *     suspend { shift("error") }
  *   }.fold({ }, { leakedShift -> leakedShift.invoke() })
  * ```
+ * <!--- KNIT example-effect-guide-13.kt -->
  *
- * The same violation is possible in all DSLs in Kotlin, including Structured Concurrency.
+ * When we invoke `leakedShift` outside of `effect { }` a special `ShiftLeakedException` is thrown to improve the debugging experience.
+ * The message clearly states that `shift` was leaked outside its scope, and the stacktrace will point to the exact location where `shift` was captured.
+ * In this case in line `9` of `example-effect-guide-13.kt`, which is stated in the second line of the stacktrace: `invokeSuspend(example-effect-guide-13.kt:9)`.
  *
+ * ```text
+ * Exception in thread "main" arrow.core.continuations.ShiftLeakedException:
+ * shift or bind was called outside of its DSL scope, and the DSL Scoped operator was leaked
+ * This is kind of usage is incorrect, make sure all calls to shift or bind occur within the lifecycle of effect { }, either { } or similar builders.
+ *
+ * See: ... for additional information.
+ * 	at arrow.core.continuations.FoldContinuation.shift(Effect.kt:770)
+ * 	at arrow.core.examples.exampleEffectGuide13.Example_effect_guide_13Kt$main$2$1.invokeSuspend(example-effect-guide-13.kt:9)
+ * 	at arrow.core.examples.exampleEffectGuide13.Example_effect_guide_13Kt$main$2$1.invoke(example-effect-guide-13.kt)
+ * ```
+ *
+ * An example with KotlinX Coroutines launch. Which can _concurrently_ leak `shift` outside of its scope.
+ * In this case by _delaying_ the invocation of `shift` by `3.seconds`,
+ * we can see that the `ShiftLeakedException` is again thrown when `shift` is invoked.
+ *
+ * <!--- INCLUDE
+ * import kotlinx.coroutines.launch
+ * import kotlinx.coroutines.delay
+ * import kotlinx.coroutines.coroutineScope
+ * import kotlinx.coroutines.runBlocking
+ * import arrow.core.continuations.effect
+ * import kotlin.time.Duration.Companion.seconds
+ *
+ * fun main(): Unit = runBlocking {
+ * -->
+ * <!--- SUFFIX
+ * }
+ * -->
  * ```kotlin
- *   val leakedAsync = coroutineScope<suspend () -> Deferred<Unit>> {
- *     suspend {
- *       async {
- *         println("I am never going to run, until I get called invoked from outside")
+ *   coroutineScope {
+ *     effect<String, Int> {
+ *       launch {
+ *         delay(3.seconds)
+ *         shift("error")
  *       }
- *     }
+ *       1
+ *     }.fold(::println, ::println)
  *   }
- *
- *   leakedAsync.invoke().await()
  * ```
- * <!--- KNIT example-effect-guide-13.kt -->
+ * ```text
+ * 1
+ * Exception in thread "main" arrow.core.continuations.ShiftLeakedException:
+ * shift or bind was called outside of its DSL scope, and the DSL Scoped operator was leaked
+ * This is kind of usage is incorrect, make sure all calls to shift or bind occur within the lifecycle of effect { }, either { } or similar builders.
+ *
+ * See: ... for additional information.
+ * 	at arrow.core.continuations.FoldContinuation.shift(Effect.kt:780)
+ * 	at arrow.core.examples.exampleEffectGuide14.Example_effect_guide_14Kt$main$1$1$1$1.invokeSuspend(example-effect-guide-14.kt:17)
+ * 	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33) <13 internal lines>
+ * 	at arrow.core.examples.exampleEffectGuide14.Example_effect_guide_14Kt.main(example-effect-guide-14.kt:11)
+ * 	at arrow.core.examples.exampleEffectGuide14.Example_effect_guide_14Kt.main(example-effect-guide-14.kt)
+ * ```
+ * <!--- KNIT example-effect-guide-14.kt -->
  */
 public interface Effect<out R, out A> {
   /**
@@ -846,11 +908,12 @@ private class DefaultEffect<R, A>(val f: suspend EffectScope<R>.() -> A) : Effec
 
 public suspend fun <A> Effect<A, A>.merge(): A = fold(::identity, ::identity)
 
-public class ShiftLeakedException : RuntimeException(
+public class ShiftLeakedException : IllegalStateException(
   """
-      "shift or bind occurred outside of its DSL scope, and the DSL scoped operator was leaked, this is kind of usage is incorrect.
-       Make sure all calls to shift or bind occur within the lifecycle of effect { }, either { } or similar.
-       
-       See: ... for additional information.
-    """.trimIndent()
+  
+  shift or bind was called outside of its DSL scope, and the DSL Scoped operator was leaked
+  This is kind of usage is incorrect, make sure all calls to shift or bind occur within the lifecycle of effect { }, either { } or similar builders.
+ 
+  See: ... for additional information.
+  """.trimIndent()
 )
diff --git a/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-11.kt b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-11.kt
index 2ba4c626c4a..dbfd80371d3 100644
--- a/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-11.kt
+++ b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-11.kt
@@ -15,6 +15,12 @@ suspend fun main() {
       val fa = async<Int> { shift(errorA) }
       val fb = async<Int> { shift(errorB) }
       fa.await() + fb.await()
-    }.fold({ error -> error shouldBeIn listOf(errorA, errorB) }, { fail("Int can never be the result") })
+    }.fold(
+      { error ->
+        println(error)
+        error shouldBeIn listOf(errorA, errorB)
+      },
+      { fail("Int can never be the result") }
+    )
   }
 }
diff --git a/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-12.kt b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-12.kt
index 4a5e8be6381..da40654688d 100644
--- a/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-12.kt
+++ b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-12.kt
@@ -10,12 +10,11 @@ import kotlinx.coroutines.launch
 suspend fun main() {
   val errorA = "ErrorA"
   val errorB = "ErrorB"
-  val int = 45
   effect<String, Int> {
     coroutineScope<Int> {
       launch { shift(errorA) }
       launch { shift(errorB) }
-      int
+      45
     }
-  }.fold({ fail("Shift can never finish") }, { it shouldBe int })
+  }.fold({ fail("Shift can never finish") }, ::println)
 }
diff --git a/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-13.kt b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-13.kt
index e2c8dcdcbea..a11ce8f3684 100644
--- a/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-13.kt
+++ b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-13.kt
@@ -2,23 +2,10 @@
 package arrow.core.examples.exampleEffectGuide13
 
 import arrow.core.continuations.effect
-import kotlinx.coroutines.Deferred
-import kotlinx.coroutines.async
-import kotlinx.coroutines.coroutineScope
 
 suspend fun main() {
 
   effect<String, suspend () -> Unit> {
     suspend { shift("error") }
   }.fold({ }, { leakedShift -> leakedShift.invoke() })
-
-  val leakedAsync = coroutineScope<suspend () -> Deferred<Unit>> {
-    suspend {
-      async {
-        println("I am never going to run, until I get called invoked from outside")
-      }
-    }
-  }
-
-  leakedAsync.invoke().await()
 }
diff --git a/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-14.kt b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-14.kt
new file mode 100644
index 00000000000..6b5d9035872
--- /dev/null
+++ b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-14.kt
@@ -0,0 +1,22 @@
+// This file was automatically generated from Effect.kt by Knit tool. Do not edit.
+package arrow.core.examples.exampleEffectGuide14
+
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.runBlocking
+import arrow.core.continuations.effect
+import kotlin.time.Duration.Companion.seconds
+
+fun main(): Unit = runBlocking {
+
+  coroutineScope {
+    effect<String, Int> {
+      launch {
+        delay(3.seconds)
+        shift("error")
+      }
+      1
+    }.fold(::println, ::println)
+  }
+}

From 349bfaa3db846a6b45aedacd6affc4cd89185ab5 Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Thu, 5 Jan 2023 15:07:42 +0100
Subject: [PATCH 03/15] Improve docs & example

---
 .../kotlin/arrow/core/continuations/Effect.kt | 21 +++++++++----------
 .../examples/example-effect-guide-14.kt       | 16 +++++++-------
 2 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
index 7fd964c4d81..a0df3d0c150 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
@@ -522,8 +522,9 @@ import kotlin.coroutines.resumeWithException
  *
  * #### launch
  *
- * It's **not allowed** to call `shift` from within `launch`, this is because `launch` creates a separate process.
- * Any calls to `shift` inside of `launch` will be ignored by `effect`, and result in an exception being thrown.
+ * It's **not allowed** to call `shift` from within `launch`, this is because `launch` creates a separate unrelated child Job/Continuation.
+ * Any calls to `shift` inside of `launch` will be ignored by `effect`, and result in an exception being thrown inside `launch`.
+ * Because KotlinX Coroutines ignores `CancellationException`, and thus swallows the `shift` call.
  *
  * <!--- INCLUDE
  * import arrow.core.continuations.effect
@@ -606,15 +607,13 @@ import kotlin.coroutines.resumeWithException
  * }
  * -->
  * ```kotlin
- *   coroutineScope {
- *     effect<String, Int> {
- *       launch {
- *         delay(3.seconds)
- *         shift("error")
- *       }
- *       1
- *     }.fold(::println, ::println)
- *   }
+ *  effect<String, Int> {
+ *    launch {
+ *      delay(3.seconds)
+ *      shift("error")
+ *    }
+ *    1
+ *  }.fold(::println, ::println)
  * ```
  * ```text
  * 1
diff --git a/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-14.kt b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-14.kt
index 6b5d9035872..2417e0de106 100644
--- a/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-14.kt
+++ b/arrow-libs/core/arrow-core/src/jvmTest/kotlin/examples/example-effect-guide-14.kt
@@ -10,13 +10,11 @@ import kotlin.time.Duration.Companion.seconds
 
 fun main(): Unit = runBlocking {
 
-  coroutineScope {
-    effect<String, Int> {
-      launch {
-        delay(3.seconds)
-        shift("error")
-      }
-      1
-    }.fold(::println, ::println)
-  }
+ effect<String, Int> {
+   launch {
+     delay(3.seconds)
+     shift("error")
+   }
+   1
+ }.fold(::println, ::println)
 }

From f4d887355375aef37b1e2c79e23605cbf0568603 Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Thu, 5 Jan 2023 15:11:30 +0100
Subject: [PATCH 04/15] replace ...

---
 .../commonMain/kotlin/arrow/core/continuations/Effect.kt    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
index a0df3d0c150..4091cb6e0d9 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
@@ -583,7 +583,7 @@ import kotlin.coroutines.resumeWithException
  * shift or bind was called outside of its DSL scope, and the DSL Scoped operator was leaked
  * This is kind of usage is incorrect, make sure all calls to shift or bind occur within the lifecycle of effect { }, either { } or similar builders.
  *
- * See: ... for additional information.
+ * See: Effect KDoc for additional information.
  * 	at arrow.core.continuations.FoldContinuation.shift(Effect.kt:770)
  * 	at arrow.core.examples.exampleEffectGuide13.Example_effect_guide_13Kt$main$2$1.invokeSuspend(example-effect-guide-13.kt:9)
  * 	at arrow.core.examples.exampleEffectGuide13.Example_effect_guide_13Kt$main$2$1.invoke(example-effect-guide-13.kt)
@@ -621,7 +621,7 @@ import kotlin.coroutines.resumeWithException
  * shift or bind was called outside of its DSL scope, and the DSL Scoped operator was leaked
  * This is kind of usage is incorrect, make sure all calls to shift or bind occur within the lifecycle of effect { }, either { } or similar builders.
  *
- * See: ... for additional information.
+ * See: Effect KDoc for additional information.
  * 	at arrow.core.continuations.FoldContinuation.shift(Effect.kt:780)
  * 	at arrow.core.examples.exampleEffectGuide14.Example_effect_guide_14Kt$main$1$1$1$1.invokeSuspend(example-effect-guide-14.kt:17)
  * 	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33) <13 internal lines>
@@ -913,6 +913,6 @@ public class ShiftLeakedException : IllegalStateException(
   shift or bind was called outside of its DSL scope, and the DSL Scoped operator was leaked
   This is kind of usage is incorrect, make sure all calls to shift or bind occur within the lifecycle of effect { }, either { } or similar builders.
  
-  See: ... for additional information.
+  See: Effect KDoc for additional information.
   """.trimIndent()
 )

From e9af81f9776858e5774c8a792b6a41e6e98535a3 Mon Sep 17 00:00:00 2001
From: nomisRev <nomisRev@users.noreply.github.com>
Date: Thu, 5 Jan 2023 14:18:02 +0000
Subject: [PATCH 05/15] Update API files

---
 arrow-libs/core/arrow-core/api/arrow-core.api | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/arrow-libs/core/arrow-core/api/arrow-core.api b/arrow-libs/core/arrow-core/api/arrow-core.api
index bf59e2f9a5c..f4f6acb47fc 100644
--- a/arrow-libs/core/arrow-core/api/arrow-core.api
+++ b/arrow-libs/core/arrow-core/api/arrow-core.api
@@ -2749,6 +2749,7 @@ public final class arrow/core/continuations/FoldContinuation : arrow/core/contin
 	public fun ensure (ZLkotlin/jvm/functions/Function0;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun getContext ()Lkotlin/coroutines/CoroutineContext;
 	public final fun getRecover ()Lkotlin/jvm/functions/Function2;
+	public final fun isActive ()Ljava/util/concurrent/atomic/AtomicReference;
 	public fun resumeWith (Ljava/lang/Object;)V
 	public final fun setRecover (Lkotlin/jvm/functions/Function2;)V
 	public fun shift (Ljava/lang/Object;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
@@ -3023,6 +3024,10 @@ public final class arrow/core/continuations/ResultKt {
 public abstract class arrow/core/continuations/ShiftCancellationException : arrow/core/continuations/CancellationExceptionNoTrace {
 }
 
+public final class arrow/core/continuations/ShiftLeakedException : java/lang/IllegalStateException {
+	public fun <init> ()V
+}
+
 public final class arrow/core/continuations/Suspend : arrow/core/continuations/ShiftCancellationException {
 	public fun <init> (Larrow/core/continuations/Token;Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)V
 	public final fun getRecover ()Lkotlin/jvm/functions/Function2;

From 31a48f37564c720065b492285c764702e72bcbd9 Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Thu, 5 Jan 2023 15:46:03 +0100
Subject: [PATCH 06/15] Retrigger CI


From 4e3f5830dd9e833b2961c44c30f615fcb5ef0120 Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Thu, 5 Jan 2023 18:47:21 +0100
Subject: [PATCH 07/15] Fix StructuredConcurrencySpec

---
 .../StructuredConcurrencySpec.kt              | 354 +++++++++---------
 1 file changed, 176 insertions(+), 178 deletions(-)

diff --git a/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/StructuredConcurrencySpec.kt b/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/StructuredConcurrencySpec.kt
index 6d10921ee5d..dd424f6f359 100644
--- a/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/StructuredConcurrencySpec.kt
+++ b/arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/continuations/StructuredConcurrencySpec.kt
@@ -4,6 +4,7 @@ import arrow.core.identity
 import arrow.fx.coroutines.ExitCase
 import arrow.fx.coroutines.guaranteeCase
 import io.kotest.assertions.fail
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.collections.shouldBeIn
 import io.kotest.matchers.nulls.shouldNotBeNull
@@ -26,216 +27,213 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withTimeout
 
-class StructuredConcurrencySpec :
-  StringSpec({
-    "async - suspendCancellableCoroutine.invokeOnCancellation is called with Shifted Continuation" {
-      val started = CompletableDeferred<Unit>()
-      val cancelled = CompletableDeferred<Throwable?>()
-
-      effect {
-          coroutineScope {
-            val never = async {
-              suspendCancellableCoroutine<Nothing> { cont ->
-                cont.invokeOnCancellation { cause ->
-                  require(cancelled.complete(cause)) { "cancelled latch was completed twice" }
-                }
-                require(started.complete(Unit))
-              }
+class StructuredConcurrencySpec : StringSpec({
+  "async - suspendCancellableCoroutine.invokeOnCancellation is called with Shifted Continuation" {
+    val started = CompletableDeferred<Unit>()
+    val cancelled = CompletableDeferred<Throwable?>()
+
+    effect {
+      coroutineScope {
+        val never = async {
+          suspendCancellableCoroutine<Nothing> { cont ->
+            cont.invokeOnCancellation { cause ->
+              require(cancelled.complete(cause)) { "cancelled latch was completed twice" }
             }
-            async<Int> {
-                started.await()
-                shift("hello")
-              }
-              .await()
-            never.await()
+            require(started.complete(Unit))
           }
         }
-        .runCont() shouldBe "hello"
-
-      withTimeout(2.seconds) {
-        cancelled.await().shouldNotBeNull().message shouldBe "Shifted Continuation"
+        async<Int> {
+          started.await()
+          shift("hello")
+        }
+          .await()
+        never.await()
       }
     }
+      .runCont() shouldBe "hello"
 
-    "Computation blocks run on parent context" {
-      val parentCtx = currentContext()
-      effect<Nothing, Unit> { currentContext() shouldBe parentCtx }.runCont()
+    withTimeout(2.seconds) {
+      cancelled.await().shouldNotBeNull().message shouldBe "Shifted Continuation"
     }
+  }
 
-    "Concurrent shift - async await" {
-      checkAll(Arb.int(), Arb.int()) { a, b ->
-        effect {
-            coroutineScope {
-              val fa = async<String> { shift(a) }
-              val fb = async<String> { shift(b) }
-              fa.await() + fb.await()
-            }
-          }
-          .runCont() shouldBeIn listOf(a, b)
-      }
-    }
+  "Computation blocks run on parent context" {
+    val parentCtx = currentContext()
+    effect<Nothing, Unit> { currentContext() shouldBe parentCtx }.runCont()
+  }
 
-    "Concurrent shift - async await exit results" {
-      checkAll(Arb.int()) { a ->
-        val scopeExit = CompletableDeferred<ExitCase>()
-        val fbExit = CompletableDeferred<ExitCase>()
-        val startLatches = (0..11).map { CompletableDeferred<Unit>() }
-        val nestedExits = (0..10).map { CompletableDeferred<ExitCase>() }
-
-        fun CoroutineScope.asyncTask(
-          start: CompletableDeferred<Unit>,
-          exit: CompletableDeferred<ExitCase>
-        ): Deferred<Unit> = async {
-          guaranteeCase({
-            start.complete(Unit)
-            awaitCancellation()
-          }) { case -> require(exit.complete(case)) }
+  "Concurrent shift - async await" {
+    checkAll(Arb.int(), Arb.int()) { a, b ->
+      effect {
+        coroutineScope {
+          val fa = async<String> { shift(a) }
+          val fb = async<String> { shift(b) }
+          fa.await() + fb.await()
         }
+      }
+        .runCont() shouldBeIn listOf(a, b)
+    }
+  }
+
+  "Concurrent shift - async await exit results" {
+    checkAll(Arb.int()) { a ->
+      val scopeExit = CompletableDeferred<ExitCase>()
+      val fbExit = CompletableDeferred<ExitCase>()
+      val startLatches = (0..11).map { CompletableDeferred<Unit>() }
+      val nestedExits = (0..10).map { CompletableDeferred<ExitCase>() }
+
+      fun CoroutineScope.asyncTask(
+        start: CompletableDeferred<Unit>,
+        exit: CompletableDeferred<ExitCase>
+      ): Deferred<Unit> = async {
+        guaranteeCase({
+          start.complete(Unit)
+          awaitCancellation()
+        }) { case -> require(exit.complete(case)) }
+      }
 
-        effect<Int, String> {
-            guaranteeCase({
-              coroutineScope {
-                val fa =
-                  async<Unit> {
-                    startLatches.drop(1).zip(nestedExits) { start, promise ->
-                      asyncTask(start, promise)
-                    }
-                    startLatches.awaitAll()
-                    shift(a)
-                  }
-                val fb = asyncTask(startLatches.first(), fbExit)
-                fa.await()
-                fb.await()
+      effect<Int, String> {
+        guaranteeCase({
+          coroutineScope {
+            val fa =
+              async<Unit> {
+                startLatches.drop(1).zip(nestedExits) { start, promise ->
+                  asyncTask(start, promise)
+                }
+                startLatches.awaitAll()
+                shift(a)
               }
-            }) { case -> require(scopeExit.complete(case)) }
-            fail("Should never come here")
+            val fb = asyncTask(startLatches.first(), fbExit)
+            fa.await()
+            fb.await()
           }
-          .runCont() shouldBe a
-        withTimeout(2.seconds) {
-          scopeExit.await().shouldBeTypeOf<ExitCase.Cancelled>()
-          fbExit.await().shouldBeTypeOf<ExitCase.Cancelled>()
-          nestedExits.awaitAll().forEach { it.shouldBeTypeOf<ExitCase.Cancelled>() }
-        }
+        }) { case -> require(scopeExit.complete(case)) }
+        fail("Should never come here")
+      }
+        .runCont() shouldBe a
+      withTimeout(2.seconds) {
+        scopeExit.await().shouldBeTypeOf<ExitCase.Cancelled>()
+        fbExit.await().shouldBeTypeOf<ExitCase.Cancelled>()
+        nestedExits.awaitAll().forEach { it.shouldBeTypeOf<ExitCase.Cancelled>() }
       }
     }
+  }
 
-    "Concurrent shift - async" {
-      checkAll(Arb.int(), Arb.int()) { a, b ->
-        effect {
-            coroutineScope {
-              val fa = async { shift<Nothing>(a) }
-              val fb = async { shift<Nothing>(b) }
-              "I will be overwritten by shift - coroutineScope waits until all async are finished"
-            }
-          }
-          .fold({ fail("Async is never awaited, and thus ignored.") }, ::identity) shouldBe
+  "Concurrent shift - async" {
+    checkAll(Arb.int(), Arb.int()) { a, b ->
+      effect {
+        coroutineScope {
+          val fa = async { shift<Nothing>(a) }
+          val fb = async { shift<Nothing>(b) }
           "I will be overwritten by shift - coroutineScope waits until all async are finished"
+        }
       }
+        .fold({ fail("Async is never awaited, and thus ignored.") }, ::identity) shouldBe
+        "I will be overwritten by shift - coroutineScope waits until all async are finished"
     }
+  }
+
+  "Concurrent shift - async exit results" {
+    checkAll(Arb.int(), Arb.string()) { a, str ->
+      val exitScope = CompletableDeferred<ExitCase>()
+      val startLatches = (0..10).map { CompletableDeferred<Unit>() }
+      val nestedExits = (0..10).map { CompletableDeferred<ExitCase>() }
+
+      fun CoroutineScope.asyncTask(
+        start: CompletableDeferred<Unit>,
+        exit: CompletableDeferred<ExitCase>
+      ): Deferred<Unit> = async {
+        guaranteeCase({
+          start.complete(Unit)
+          awaitCancellation()
+        }) { case -> require(exit.complete(case)) }
+      }
 
-    "Concurrent shift - async exit results" {
-      checkAll(Arb.int(), Arb.string()) { a, str ->
-        val exitScope = CompletableDeferred<ExitCase>()
-        val startLatches = (0..10).map { CompletableDeferred<Unit>() }
-        val nestedExits = (0..10).map { CompletableDeferred<ExitCase>() }
-
-        fun CoroutineScope.asyncTask(
-          start: CompletableDeferred<Unit>,
-          exit: CompletableDeferred<ExitCase>
-        ): Deferred<Unit> = async {
-          guaranteeCase({
-            start.complete(Unit)
-            awaitCancellation()
-          }) { case -> require(exit.complete(case)) }
-        }
-
-        effect {
-            guaranteeCase({
-              coroutineScope {
-                val fa =
-                  async<Unit> {
-                    startLatches.zip(nestedExits) { start, promise -> asyncTask(start, promise) }
-                    startLatches.awaitAll()
-                    shift(a)
-                  }
-                str
+      effect {
+        guaranteeCase({
+          coroutineScope {
+            val fa =
+              async<Unit> {
+                startLatches.zip(nestedExits) { start, promise -> asyncTask(start, promise) }
+                startLatches.awaitAll()
+                shift(a)
               }
-            }) { case -> require(exitScope.complete(case)) }
+            str
           }
-          .runCont() shouldBe str
-
-        withTimeout(2.seconds) {
-          nestedExits.awaitAll().forEach { it.shouldBeTypeOf<ExitCase.Cancelled>() }
-        }
+        }) { case -> require(exitScope.complete(case)) }
       }
-    }
+        .runCont() shouldBe str
 
-    "Concurrent shift - launch" {
-      checkAll(Arb.int(), Arb.int()) { a, b ->
-        effect {
-            coroutineScope {
-              launch { shift(a) }
-              launch { shift(b) }
-              "shift does not escape `launch`"
-            }
-          }
-          .runCont() shouldBe "shift does not escape `launch`"
+      withTimeout(2.seconds) {
+        nestedExits.awaitAll().forEach { it.shouldBeTypeOf<ExitCase.Cancelled>() }
       }
     }
+  }
 
-    "Concurrent shift - launch exit results" {
-      checkAll(Arb.int(), Arb.string()) { a, str ->
-        val scopeExit = CompletableDeferred<ExitCase>()
-        val startLatches = (0..10).map { CompletableDeferred<Unit>() }
-        val nestedExits = (0..10).map { CompletableDeferred<ExitCase>() }
-
-        fun CoroutineScope.launchTask(
-          start: CompletableDeferred<Unit>,
-          exit: CompletableDeferred<ExitCase>
-        ): Job = launch {
-          guaranteeCase({
-            start.complete(Unit)
-            awaitCancellation()
-          }) { case -> require(exit.complete(case)) }
-        }
-
-        effect {
-            guaranteeCase({
-              coroutineScope {
-                val fa = launch {
-                  startLatches.zip(nestedExits) { start, promise -> launchTask(start, promise) }
-                  startLatches.awaitAll()
-                  shift(a)
-                }
-                str
-              }
-            }) { case -> require(scopeExit.complete(case)) }
-          }
-          .runCont() shouldBe str
-        withTimeout(2.seconds) {
-          scopeExit.await().shouldBeTypeOf<ExitCase.Completed>()
-          nestedExits.awaitAll().forEach { it.shouldBeTypeOf<ExitCase.Cancelled>() }
+  "Concurrent shift - launch" {
+    checkAll(Arb.int(), Arb.int()) { a, b ->
+      effect {
+        coroutineScope {
+          launch { shift(a) }
+          launch { shift(b) }
+          "shift does not escape `launch`"
         }
       }
+        .runCont() shouldBe "shift does not escape `launch`"
     }
+  }
+
+  "Concurrent shift - launch exit results" {
+    checkAll(Arb.int(), Arb.string()) { a, str ->
+      val scopeExit = CompletableDeferred<ExitCase>()
+      val startLatches = (0..10).map { CompletableDeferred<Unit>() }
+      val nestedExits = (0..10).map { CompletableDeferred<ExitCase>() }
+
+      fun CoroutineScope.launchTask(
+        start: CompletableDeferred<Unit>,
+        exit: CompletableDeferred<ExitCase>
+      ): Job = launch {
+        guaranteeCase({
+          start.complete(Unit)
+          awaitCancellation()
+        }) { case -> require(exit.complete(case)) }
+      }
 
-    // `shift` escapes `cont` block, and gets rethrown inside `coroutineScope`.
-    // Effectively awaiting/executing DSL code, outside of the DSL...
-    "async funky scenario #1 - Extract `shift` from `cont` through `async`" {
-      checkAll(Arb.int(), Arb.int()) { a, b ->
-        runCatching {
-            coroutineScope {
-              val shiftedAsync =
-                effect<Int, Deferred<String>> {
-                    val fa = async<Int> { shift(a) }
-                    async { shift(b) }
-                  }
-                  .fold({ fail("shift was never awaited, so it never took effect") }, ::identity)
-              shiftedAsync.await()
+      effect {
+        guaranteeCase({
+          coroutineScope {
+            val fa = launch {
+              startLatches.zip(nestedExits) { start, promise -> launchTask(start, promise) }
+              startLatches.awaitAll()
+              shift(a)
             }
+            str
           }
-          .exceptionOrNull()
-          ?.message shouldBe "Shifted Continuation"
+        }) { case -> require(scopeExit.complete(case)) }
+      }
+        .runCont() shouldBe str
+      withTimeout(2.seconds) {
+        scopeExit.await().shouldBeTypeOf<ExitCase.Completed>()
+        nestedExits.awaitAll().forEach { it.shouldBeTypeOf<ExitCase.Cancelled>() }
+      }
+    }
+  }
+
+  // `shift` escapes `cont` block, and gets rethrown inside `coroutineScope`.
+  // Effectively awaiting/executing DSL code, outside of the DSL...
+  "async funky scenario #1 - Extract `shift` from `cont` through `async`" {
+    checkAll(Arb.int(), Arb.int()) { a, b ->
+      shouldThrow<ShiftLeakedException> {
+        coroutineScope {
+          val shiftedAsync =
+            effect<Int, Deferred<String>> {
+              val fa = async<Int> { shift(a) }
+              async { shift(b) }
+            }
+              .fold({ fail("shift was never awaited, so it never took effect") }, ::identity)
+          shiftedAsync.await()
+        }
       }
     }
-  })
+  }
+})

From 07b41690a00abf7651827ba4593085e0009c0f8e Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Mon, 9 Jan 2023 13:54:59 +0100
Subject: [PATCH 08/15] Update
 arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt

Co-authored-by: Francisco Diaz <francisco.d@47deg.com>
---
 .../src/commonMain/kotlin/arrow/core/continuations/Effect.kt    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
index 4091cb6e0d9..cd23a165590 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
@@ -517,7 +517,7 @@ import kotlin.coroutines.resumeWithException
  * ErrorA
  * ```
  *
- * The example here will always print `ErrorA`, but never `ErrorB`. This is because `fa` is awaited first, and when it's `shifts` it will cancel `fb`.
+ * The example here will always print `ErrorA`, but never `ErrorB`. This is because `fa` is awaited first, and when it `shifts` it will cancel `fb`.
  * If instead we used `awaitAll`, then it would print `ErrorA` or `ErrorB` due to both `fa` and `fb` being awaited in parallel.
  *
  * #### launch

From b2b88ccadfff7d5ea2202db7b7e434f0ebdb5f4d Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Mon, 9 Jan 2023 21:29:40 +0100
Subject: [PATCH 09/15] Update
 arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt

Co-authored-by: Francisco Diaz <francisco.d@47deg.com>
---
 .../src/commonMain/kotlin/arrow/core/continuations/Effect.kt  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
index cd23a165590..d67e3a4d9b9 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
@@ -522,8 +522,8 @@ import kotlin.coroutines.resumeWithException
  *
  * #### launch
  *
- * It's **not allowed** to call `shift` from within `launch`, this is because `launch` creates a separate unrelated child Job/Continuation.
- * Any calls to `shift` inside of `launch` will be ignored by `effect`, and result in an exception being thrown inside `launch`.
+ * It's **not allowed** to call `shift` from within `launch`. This is because `launch` creates a separate unrelated child Job/Continuation.
+ * Any calls to `shift` inside of `launch` will be ignored by `effect` and result in an exception being thrown inside `launch`.
  * Because KotlinX Coroutines ignores `CancellationException`, and thus swallows the `shift` call.
  *
  * <!--- INCLUDE

From 87ea7f139531ba88731f74664debe90c95d9cde2 Mon Sep 17 00:00:00 2001
From: Alejandro Serrano <trupill@gmail.com>
Date: Sun, 8 Jan 2023 13:37:03 +0100
Subject: [PATCH 10/15] Mention Arrow 2.0 in README (#2878)

---
 README.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/README.md b/README.md
index b432f390580..abe1da10f63 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,17 @@ Use the list below to learn more about Λrrow's main features.
 If you have a blog post, talk, or upcoming event on Arrow, please considering opening an issue or PR
 to add to the collection over at the [Arrow Media](https://github.com/arrow-kt/arrow-media) repo.
 
+## Arrow 2.0
+
+The next version of Arrow is [in active development](https://github.com/arrow-kt/arrow/pull/2778).
+If you want to try it, you need to add the following repository in your build file:
+
+```
+maven("https://oss.sonatype.org/content/repositories/snapshots")
+```
+
+and depend on the `2.0.0-SNAPSHOT` version of the desired library.
+
 ## Join Us
 
 Arrow is an inclusive community powered by awesome individuals like you. As an actively growing

From 49f8cc92a474dde1d0cd5a4d75d92ee4bfa66cbd Mon Sep 17 00:00:00 2001
From: Alejandro Serrano <trupill@gmail.com>
Date: Mon, 9 Jan 2023 10:28:17 +0100
Subject: [PATCH 11/15] Prisms for Either (#2877)

Co-authored-by: Simon Vergauwen <nomisRev@users.noreply.github.com>
---
 .../optics/arrow-optics/api/arrow-optics.api  | 17 ++++++
 .../commonMain/kotlin/arrow/optics/Prism.kt   | 45 +++++++++++++++
 .../kotlin/arrow/optics/dsl/either.kt         | 56 +++++++++++++++++++
 3 files changed, 118 insertions(+)
 create mode 100644 arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/dsl/either.kt

diff --git a/arrow-libs/optics/arrow-optics/api/arrow-optics.api b/arrow-libs/optics/arrow-optics/api/arrow-optics.api
index 970a6993266..03e6edcdde2 100644
--- a/arrow-libs/optics/arrow-optics/api/arrow-optics.api
+++ b/arrow-libs/optics/arrow-optics/api/arrow-optics.api
@@ -598,6 +598,8 @@ public final class arrow/optics/POptionalGetter$DefaultImpls {
 public abstract interface class arrow/optics/PPrism : arrow/optics/PEvery, arrow/optics/POptional, arrow/optics/POptionalGetter, arrow/optics/PSetter, arrow/optics/PTraversal {
 	public static final field Companion Larrow/optics/PPrism$Companion;
 	public abstract fun compose (Larrow/optics/PPrism;)Larrow/optics/PPrism;
+	public static fun eitherLeft ()Larrow/optics/PPrism;
+	public static fun eitherRight ()Larrow/optics/PPrism;
 	public abstract fun first ()Larrow/optics/PPrism;
 	public abstract fun foldMap (Larrow/typeclasses/Monoid;Ljava/lang/Object;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 	public abstract fun getOrModify (Ljava/lang/Object;)Larrow/core/Either;
@@ -605,6 +607,8 @@ public abstract interface class arrow/optics/PPrism : arrow/optics/PEvery, arrow
 	public abstract fun liftNullable (Lkotlin/jvm/functions/Function1;)Lkotlin/jvm/functions/Function1;
 	public abstract fun modify (Ljava/lang/Object;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
 	public static fun none ()Larrow/optics/PPrism;
+	public static fun pLeft ()Larrow/optics/PPrism;
+	public static fun pRight ()Larrow/optics/PPrism;
 	public static fun pSome ()Larrow/optics/PPrism;
 	public abstract fun plus (Larrow/optics/PPrism;)Larrow/optics/PPrism;
 	public abstract fun reverseGet (Ljava/lang/Object;)Ljava/lang/Object;
@@ -615,11 +619,15 @@ public abstract interface class arrow/optics/PPrism : arrow/optics/PEvery, arrow
 }
 
 public final class arrow/optics/PPrism$Companion {
+	public final fun eitherLeft ()Larrow/optics/PPrism;
+	public final fun eitherRight ()Larrow/optics/PPrism;
 	public final fun id ()Larrow/optics/PIso;
 	public final fun invoke (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;)Larrow/optics/PPrism;
 	public final fun none ()Larrow/optics/PPrism;
 	public final fun only (Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Larrow/optics/PPrism;
 	public static synthetic fun only$default (Larrow/optics/PPrism$Companion;Ljava/lang/Object;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Larrow/optics/PPrism;
+	public final fun pLeft ()Larrow/optics/PPrism;
+	public final fun pRight ()Larrow/optics/PPrism;
 	public final fun pSome ()Larrow/optics/PPrism;
 	public final fun some ()Larrow/optics/PPrism;
 }
@@ -813,6 +821,15 @@ public final class arrow/optics/dsl/AtKt {
 	public static final fun at (Larrow/optics/PTraversal;Larrow/optics/typeclasses/At;Ljava/lang/Object;)Larrow/optics/PTraversal;
 }
 
+public final class arrow/optics/dsl/EitherKt {
+	public static final fun getLeft (Larrow/optics/POptional;)Larrow/optics/POptional;
+	public static final fun getLeft (Larrow/optics/PPrism;)Larrow/optics/PPrism;
+	public static final fun getLeft (Larrow/optics/PTraversal;)Larrow/optics/PTraversal;
+	public static final fun getRight (Larrow/optics/POptional;)Larrow/optics/POptional;
+	public static final fun getRight (Larrow/optics/PPrism;)Larrow/optics/PPrism;
+	public static final fun getRight (Larrow/optics/PTraversal;)Larrow/optics/PTraversal;
+}
+
 public final class arrow/optics/dsl/EveryKt {
 	public static final fun every (Larrow/optics/Fold;Larrow/optics/PEvery;)Larrow/optics/Fold;
 	public static final fun every (Larrow/optics/PIso;Larrow/optics/PEvery;)Larrow/optics/PEvery;
diff --git a/arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/Prism.kt b/arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/Prism.kt
index 46a0658c564..bd01e0eb1a1 100644
--- a/arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/Prism.kt
+++ b/arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/Prism.kt
@@ -7,7 +7,10 @@ import arrow.core.Some
 import arrow.core.compose
 import arrow.core.flatMap
 import arrow.core.identity
+import arrow.core.left
+import arrow.core.right
 import arrow.typeclasses.Monoid
+import kotlin.jvm.JvmName
 import kotlin.jvm.JvmStatic
 
 /**
@@ -172,6 +175,48 @@ public interface PPrism<S, T, A, B> : POptional<S, T, A, B>, PSetter<S, T, A, B>
         getOrModify = { option -> option.fold({ Either.Right(Unit) }, { Either.Left(option) }) },
         reverseGet = { _ -> None }
       )
+
+    /**
+     * [Prism] to focus into an [arrow.core.Either.Left]
+     */
+    @JvmStatic @JvmName("eitherLeft")
+    public fun <L, R> left(): Prism<Either<L, R>, L> = pLeft()
+      
+    /**
+     * [Prism] to focus into an [arrow.core.Either.Right]
+     */
+    @JvmStatic @JvmName("eitherRight")
+    public fun <L, R> right(): Prism<Either<L, R>, R> = pRight()
+
+    /**
+     * Polymorphic [PPrism] to focus into an [arrow.core.Either.Left]
+     */
+    @JvmStatic
+    public fun <L, R, E> pLeft(): PPrism<Either<L, R>, Either<E, R>, L, E> =
+      Prism(
+        getOrModify = { e ->
+          when (e) {
+            is Either.Left -> e.value.right()
+            is Either.Right -> e.left()
+          }
+        },
+        reverseGet = { it.left() }
+      )
+
+    /**
+     * Polymorphic [PPrism] to focus into an [arrow.core.Either.Right]
+     */
+    @JvmStatic
+    public fun <L, R, B> pRight(): PPrism<Either<L, R>, Either<L, B>, R, B> =
+      PPrism(
+        getOrModify = { e ->
+          when (e) {
+            is Either.Left -> e.left()
+            is Either.Right -> e.value.right()
+          }
+        },
+        reverseGet = { it.right() }
+      )
   }
 }
 
diff --git a/arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/dsl/either.kt b/arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/dsl/either.kt
new file mode 100644
index 00000000000..c39f046ec95
--- /dev/null
+++ b/arrow-libs/optics/arrow-optics/src/commonMain/kotlin/arrow/optics/dsl/either.kt
@@ -0,0 +1,56 @@
+package arrow.optics.dsl
+
+import arrow.core.Either
+import arrow.optics.Lens
+import arrow.optics.Optional
+import arrow.optics.PPrism
+import arrow.optics.Prism
+import arrow.optics.Traversal
+
+/**
+ * DSL to compose a [Prism] with focus [Either] with a [Prism] with a focus of [Either.Left]<[L]>
+ *
+ * @receiver [Prism] with a focus in [Either]
+ * @return [Prism] with a focus in [L]
+ */
+public inline val <A, L, R> Prism<A, Either<L, R>>.left: Prism<A, L> inline get() = this.compose(PPrism.left())
+
+/**
+ * DSL to compose a [Optional] with focus [Either] with a [Prism] with a focus of [Either.Left]<[L]>
+ *
+ * @receiver [Lens] or [Optional] with a focus in [Either]
+ * @return [Optional] with a focus in [L]
+ */
+public inline val <A, L, R> Optional<A, Either<L, R>>.left: Optional<A, L> inline get() = this.compose(PPrism.left())
+
+/**
+ * DSL to compose a [Traversal] with focus [Either] with a [Prism] with a focus of [Either.Left]<[L]>
+ *
+ * @receiver [Traversal] with a focus in [Either]
+ * @return [Traversal] with a focus in [L]
+ */
+public inline val <A, L, R> Traversal<A, Either<L, R>>.left: Traversal<A, L> inline get() = this.compose(PPrism.left())
+
+/**
+ * DSL to compose a [Prism] with focus [Either] with a [Prism] with a focus of [Either.Right]<[R]>
+ *
+ * @receiver [Prism] with a focus in [Either]
+ * @return [Prism] with a focus in [R]
+ */
+public inline val <A, L, R> Prism<A, Either<L, R>>.right: Prism<A, R> inline get() = this.compose(PPrism.right())
+
+/**
+ * DSL to compose a [Optional] with focus [Either] with a [Prism] with a focus of [Either.Right]<[R]>
+ *
+ * @receiver [Lens] or [Optional] with a focus in [Either]
+ * @return [Optional] with a focus in [R]
+ */
+public inline val <A, L, R> Optional<A, Either<L, R>>.right: Optional<A, R> inline get() = this.compose(PPrism.right())
+
+/**
+ * DSL to compose a [Traversal] with focus [Either] with a [Prism] with a focus of [Either.Right]<[R]>
+ *
+ * @receiver [Traversal] with a focus in [Either]
+ * @return [Traversal] with a focus in [R]
+ */
+public inline val <A, L, R> Traversal<A, Either<L, R>>.right: Traversal<A, R> inline get() = this.compose(PPrism.right())

From 55e8c481d18277af6c28a3329a7d2fa15e9d3611 Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Mon, 9 Jan 2023 12:12:22 +0100
Subject: [PATCH 12/15] Update to 1.8.0 (#2864)

Co-authored-by: Alejandro Serrano <trupill@gmail.com>
---
 .github/workflows/pull_request.yml                |  3 ---
 .../kotlin/arrow/fx/coroutines/CircuitBreaker.kt  | 15 +++++++--------
 .../kotlin/arrow/fx/coroutines/Schedule.kt        |  2 +-
 .../kotlin/examples/example-circuitbreaker-01.kt  |  7 +++----
 .../kotlin/examples/example-circuitbreaker-02.kt  |  8 ++++----
 .../kotlin/examples/example-schedule-08.kt        |  2 +-
 gradle/libs.versions.toml                         |  4 ++--
 7 files changed, 18 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml
index b6de70d8ae7..dccb7773060 100644
--- a/.github/workflows/pull_request.yml
+++ b/.github/workflows/pull_request.yml
@@ -21,9 +21,6 @@ jobs:
           distribution: 'zulu'
           java-version: 11
 
-      - name: Install watchOS simulator
-        run: xcrun simctl create "Apple Watch Series 5 - 44mm" "com.apple.CoreSimulator.SimDeviceType.Apple-Watch-Series-5-44mm" "com.apple.CoreSimulator.SimRuntime.watchOS-9-1"
-
       - name: ios and watchos tests
         uses: gradle/gradle-build-action@v2
         with:
diff --git a/arrow-libs/fx/arrow-fx-coroutines/src/commonMain/kotlin/arrow/fx/coroutines/CircuitBreaker.kt b/arrow-libs/fx/arrow-fx-coroutines/src/commonMain/kotlin/arrow/fx/coroutines/CircuitBreaker.kt
index 81c991cde98..4cf59d0c681 100644
--- a/arrow-libs/fx/arrow-fx-coroutines/src/commonMain/kotlin/arrow/fx/coroutines/CircuitBreaker.kt
+++ b/arrow-libs/fx/arrow-fx-coroutines/src/commonMain/kotlin/arrow/fx/coroutines/CircuitBreaker.kt
@@ -41,9 +41,8 @@ import kotlin.time.DurationUnit
  *
  * ```kotlin
  * import arrow.core.Either
- * import arrow.core.flatten
  * import arrow.fx.coroutines.CircuitBreaker
- * import kotlin.time.Duration
+ * import kotlin.time.Duration.Companion.seconds
  * import kotlin.time.ExperimentalTime
  * import kotlinx.coroutines.delay
  *
@@ -52,9 +51,9 @@ import kotlin.time.DurationUnit
  * //sampleStart
  *   val circuitBreaker = CircuitBreaker.of(
  *     maxFailures = 2,
- *     resetTimeout = Duration.seconds(2),
+ *     resetTimeout = 2.seconds,
  *     exponentialBackoffFactor = 1.2,
- *     maxResetTimeout = Duration.seconds(60),
+ *     maxResetTimeout = 60.seconds,
  *   )
  *   circuitBreaker.protectOrThrow { "I am in Closed: ${circuitBreaker.state()}" }.also(::println)
  *
@@ -99,9 +98,9 @@ import kotlin.time.DurationUnit
  *   //sampleStart
  *   val circuitBreaker = CircuitBreaker.of(
  *     maxFailures = 2,
- *     resetTimeout = seconds(2),
+ *     resetTimeout = 2.seconds,
  *     exponentialBackoffFactor = 2.0, // enable exponentialBackoffFactor
- *     maxResetTimeout = seconds(60), // limit exponential back-off time
+ *     maxResetTimeout = 60.seconds, // limit exponential back-off time
  *   )
  *
  *   suspend fun <A> resilient(schedule: Schedule<Throwable, *>, f: suspend () -> A): A =
@@ -116,11 +115,11 @@ import kotlin.time.DurationUnit
  *
  *   // Retry once and when the CircuitBreaker opens after 2 failures then retry with exponential back-off with same time as CircuitBreaker's resetTimeout
  *   val fiveTimesWithBackOff = Schedule.recurs<Throwable>(1) andThen
- *     Schedule.exponential(seconds(2)) and Schedule.recurs(5)
+ *     Schedule.exponential(2.seconds) and Schedule.recurs(5)
  *
  *   Either.catch {
  *     resilient(fiveTimesWithBackOff, ::apiCall)
- *   }.let { println("exponential(seconds(2)) and recurs(5) always retries with actual apiCall: $it") }
+ *   }.let { println("exponential(2.seconds) and recurs(5) always retries with actual apiCall: $it") }
  *   //sampleEnd
  * }
  * ```
diff --git a/arrow-libs/fx/arrow-fx-coroutines/src/commonMain/kotlin/arrow/fx/coroutines/Schedule.kt b/arrow-libs/fx/arrow-fx-coroutines/src/commonMain/kotlin/arrow/fx/coroutines/Schedule.kt
index 10d06ef1d28..246d38a2f44 100644
--- a/arrow-libs/fx/arrow-fx-coroutines/src/commonMain/kotlin/arrow/fx/coroutines/Schedule.kt
+++ b/arrow-libs/fx/arrow-fx-coroutines/src/commonMain/kotlin/arrow/fx/coroutines/Schedule.kt
@@ -192,7 +192,7 @@ import kotlin.time.DurationUnit.NANOSECONDS
  * A common algorithm to retry effectful operations, as network requests, is the exponential backoff algorithm. There is a scheduling policy that implements this algorithm and can be used as:
  *
  * ```kotlin
- * import kotlin.time.milliseconds
+ * import kotlin.time.Duration.Companion.milliseconds
  * import kotlin.time.ExperimentalTime
  * import arrow.fx.coroutines.*
  *
diff --git a/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-circuitbreaker-01.kt b/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-circuitbreaker-01.kt
index 20d6f11dd07..2fa0b9e43b3 100644
--- a/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-circuitbreaker-01.kt
+++ b/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-circuitbreaker-01.kt
@@ -2,9 +2,8 @@
 package arrow.fx.coroutines.examples.exampleCircuitbreaker01
 
 import arrow.core.Either
-import arrow.core.flatten
 import arrow.fx.coroutines.CircuitBreaker
-import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
 import kotlin.time.ExperimentalTime
 import kotlinx.coroutines.delay
 
@@ -12,9 +11,9 @@ import kotlinx.coroutines.delay
 suspend fun main(): Unit {
   val circuitBreaker = CircuitBreaker.of(
     maxFailures = 2,
-    resetTimeout = Duration.seconds(2),
+    resetTimeout = 2.seconds,
     exponentialBackoffFactor = 1.2,
-    maxResetTimeout = Duration.seconds(60),
+    maxResetTimeout = 60.seconds,
   )
   circuitBreaker.protectOrThrow { "I am in Closed: ${circuitBreaker.state()}" }.also(::println)
 
diff --git a/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-circuitbreaker-02.kt b/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-circuitbreaker-02.kt
index 978b08ec240..360172174c1 100644
--- a/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-circuitbreaker-02.kt
+++ b/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-circuitbreaker-02.kt
@@ -19,9 +19,9 @@ suspend fun main(): Unit {
   //sampleStart
   val circuitBreaker = CircuitBreaker.of(
     maxFailures = 2,
-    resetTimeout = seconds(2),
+    resetTimeout = 2.seconds,
     exponentialBackoffFactor = 2.0, // enable exponentialBackoffFactor
-    maxResetTimeout = seconds(60), // limit exponential back-off time
+    maxResetTimeout = 60.seconds, // limit exponential back-off time
   )
 
   suspend fun <A> resilient(schedule: Schedule<Throwable, *>, f: suspend () -> A): A =
@@ -36,10 +36,10 @@ suspend fun main(): Unit {
 
   // Retry once and when the CircuitBreaker opens after 2 failures then retry with exponential back-off with same time as CircuitBreaker's resetTimeout
   val fiveTimesWithBackOff = Schedule.recurs<Throwable>(1) andThen
-    Schedule.exponential(seconds(2)) and Schedule.recurs(5)
+    Schedule.exponential(2.seconds) and Schedule.recurs(5)
 
   Either.catch {
     resilient(fiveTimesWithBackOff, ::apiCall)
-  }.let { println("exponential(seconds(2)) and recurs(5) always retries with actual apiCall: $it") }
+  }.let { println("exponential(2.seconds) and recurs(5) always retries with actual apiCall: $it") }
   //sampleEnd
 }
diff --git a/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-schedule-08.kt b/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-schedule-08.kt
index 52ea244a301..c333ee73f87 100644
--- a/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-schedule-08.kt
+++ b/arrow-libs/fx/arrow-fx-coroutines/src/jvmTest/kotlin/examples/example-schedule-08.kt
@@ -1,7 +1,7 @@
 // This file was automatically generated from Schedule.kt by Knit tool. Do not edit.
 package arrow.fx.coroutines.examples.exampleSchedule08
 
-import kotlin.time.milliseconds
+import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.ExperimentalTime
 import arrow.fx.coroutines.*
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 02d36222a5d..19d8125c22a 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -11,11 +11,11 @@ jUnitVintage = "5.8.2"
 kotest = "5.5.4"
 kotestGradle = "5.5.4"
 kover = "0.6.1"
-kotlin = "1.7.22"
+kotlin = "1.8.0"
 kotlinBinaryCompatibilityValidator = "0.12.1"
 kotlinCompileTesting = "1.4.9"
 knit = "0.4.0"
-kspVersion = "1.7.22-1.0.8"
+kspVersion = "1.8.0-1.0.8"
 kotlinxSerialization = "1.4.1"
 mockWebServer = "4.10.0"
 retrofit = "2.9.0"

From 4d1adbfd1765dd6452cdba25118780115d56ac01 Mon Sep 17 00:00:00 2001
From: Alejandro Serrano <trupill@gmail.com>
Date: Mon, 9 Jan 2023 16:34:40 +0100
Subject: [PATCH 13/15] Implement 'align' using 'buildList' (#2886)

Co-authored-by: Simon Vergauwen <nomisRev@users.noreply.github.com>
---
 .../commonMain/kotlin/arrow/core/Iterable.kt  | 27 ++++++++++---------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/Iterable.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/Iterable.kt
index c3bd1d2f16d..813eb0e110a 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/Iterable.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/Iterable.kt
@@ -632,7 +632,19 @@ public fun <A, B> Iterable<A>.rightPadZip(other: Iterable<B>): List<Pair<A, B?>>
  * <!--- KNIT example-iterable-07.kt -->
  */
 public inline fun <A, B, C> Iterable<A>.align(b: Iterable<B>, fa: (Ior<A, B>) -> C): List<C> =
-  this.align(b).map(fa)
+  buildList(maxOf(this.collectionSizeOrDefault(10), b.collectionSizeOrDefault(10))) {
+    val first = this@align.iterator()
+    val second = b.iterator()
+    while (first.hasNext() || second.hasNext()) {
+      val element: Ior<A, B> = when {
+        first.hasNext() && second.hasNext() -> Ior.Both(first.next(), second.next())
+        first.hasNext() -> first.next().leftIor()
+        second.hasNext() -> second.next().rightIor()
+        else -> throw IllegalStateException("this should never happen")
+      }
+      add(fa(element))
+    }
+  }
 
 /**
  * Combines two structures by taking the union of their shapes and using Ior to hold the elements.
@@ -651,18 +663,7 @@ public inline fun <A, B, C> Iterable<A>.align(b: Iterable<B>, fa: (Ior<A, B>) ->
  * <!--- KNIT example-iterable-08.kt -->
  */
 public fun <A, B> Iterable<A>.align(b: Iterable<B>): List<Ior<A, B>> =
-  alignRec(this, b)
-
-@Suppress("NAME_SHADOWING")
-private fun <X, Y> alignRec(ls: Iterable<X>, rs: Iterable<Y>): List<Ior<X, Y>> {
-  val ls = if (ls is List) ls else ls.toList()
-  val rs = if (rs is List) rs else rs.toList()
-  return when {
-    ls.isEmpty() -> rs.map { it.rightIor() }
-    rs.isEmpty() -> ls.map { it.leftIor() }
-    else -> listOf(Ior.Both(ls.first(), rs.first())) + alignRec(ls.drop(1), rs.drop(1))
-  }
-}
+  this.align(b, ::identity)
 
 /**
  * aligns two structures and combine them with the given [Semigroup.combine]

From be89b3ebc4047c45c5289ef9c676204267091baa Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Tue, 10 Jan 2023 12:43:58 +0100
Subject: [PATCH 14/15] Hide atomic behind complete method

---
 arrow-libs/core/arrow-core/api/arrow-core.api |  1 -
 .../kotlin/arrow/core/continuations/Effect.kt | 43 ++++++++++---------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/arrow-libs/core/arrow-core/api/arrow-core.api b/arrow-libs/core/arrow-core/api/arrow-core.api
index f4f6acb47fc..5e69f590c55 100644
--- a/arrow-libs/core/arrow-core/api/arrow-core.api
+++ b/arrow-libs/core/arrow-core/api/arrow-core.api
@@ -2749,7 +2749,6 @@ public final class arrow/core/continuations/FoldContinuation : arrow/core/contin
 	public fun ensure (ZLkotlin/jvm/functions/Function0;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public fun getContext ()Lkotlin/coroutines/CoroutineContext;
 	public final fun getRecover ()Lkotlin/jvm/functions/Function2;
-	public final fun isActive ()Ljava/util/concurrent/atomic/AtomicReference;
 	public fun resumeWith (Ljava/lang/Object;)V
 	public final fun setRecover (Lkotlin/jvm/functions/Function2;)V
 	public fun shift (Ljava/lang/Object;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
index d67e3a4d9b9..56aa6386e13 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
@@ -26,19 +26,19 @@ import kotlin.coroutines.resumeWithException
  *
  * <!--- TOC -->
 
-      * [Writing a program with Effect<R, A>](#writing-a-program-with-effect<r-a>)
-      * [Handling errors](#handling-errors)
-      * [Structured Concurrency](#structured-concurrency)
-        * [Arrow Fx Coroutines](#arrow-fx-coroutines)
-          * [parZip](#parzip)
-          * [parTraverse](#partraverse)
-          * [raceN](#racen)
-          * [bracketCase / Resource](#bracketcase--resource)
-        * [KotlinX](#kotlinx)
-          * [withContext](#withcontext)
-          * [async](#async)
-          * [launch](#launch)
-          * [Leaking `shift`](#leaking-shift)
+ * [Writing a program with Effect<R, A>](#writing-a-program-with-effect<r-a>)
+ * [Handling errors](#handling-errors)
+ * [Structured Concurrency](#structured-concurrency)
+ * [Arrow Fx Coroutines](#arrow-fx-coroutines)
+ * [parZip](#parzip)
+ * [parTraverse](#partraverse)
+ * [raceN](#racen)
+ * [bracketCase / Resource](#bracketcase--resource)
+ * [KotlinX](#kotlinx)
+ * [withContext](#withcontext)
+ * [async](#async)
+ * [launch](#launch)
+ * [Leaking `shift`](#leaking-shift)
 
  * <!--- END -->
  *
@@ -788,8 +788,9 @@ internal class FoldContinuation<R, B>(
 
   lateinit var recover: suspend (R) -> Any?
 
-  // Add AtomicBoolean to arrow-atomic
-  val isActive: AtomicRef<Boolean> = AtomicRef(true)
+  private val isActive: AtomicRef<Boolean> = AtomicRef(true)
+
+  internal fun complete(): Boolean = isActive.getAndSet(false)
 
   // Shift away from this Continuation by intercepting it, and completing it with
   // ShiftCancellationException
@@ -803,7 +804,7 @@ internal class FoldContinuation<R, B>(
   // CancellationException and thus effectively recovering from the cancellation/shift.
   // This means try/catch is also capable of recovering from monadic errors.
     // See: EffectSpec - try/catch tests
-    if (isActive.get()) throw Suspend(this, r, recover as suspend (Any?) -> Any?)
+    if (complete()) throw Suspend(this, r, recover as suspend (Any?) -> Any?)
     else throw ShiftLeakedException()
 
   // In contrast to `createCoroutineUnintercepted this doesn't create a new ContinuationImpl
@@ -823,13 +824,13 @@ internal class FoldContinuation<R, B>(
     result.fold(parent::resume) { throwable ->
       when {
         throwable is Suspend && this === throwable.token -> {
-          isActive.set(false)
+          complete()
           suspend { throwable.recover(throwable.shifted) as B }.startCoroutineUnintercepted()
         }
 
         throwable is Suspend -> parent.resumeWith(result)
         else -> {
-          isActive.set(false)
+          complete()
           suspend { error(throwable.nonFatalOrThrow()) }.startCoroutineUnintercepted()
         }
       }
@@ -887,18 +888,18 @@ private class DefaultEffect<R, A>(val f: suspend EffectScope<R>.() -> A) : Effec
       shift.recover = recover
       try {
         val fold: suspend EffectScope<R>.() -> B = {
-          val res = f(this).also { shift.isActive.set(false) }
+          val res = f(this).also { shift.complete() }
           transform(res)
         }
         fold.startCoroutineUninterceptedOrReturn(shift, shift)
       } catch (e: Suspend) {
         if (shift === e.token) {
-          shift.isActive.set(false)
+          shift.complete()
           val f: suspend () -> B = { e.recover(e.shifted) as B }
           f.startCoroutineUninterceptedOrReturn(cont)
         } else throw e
       } catch (e: Throwable) {
-        shift.isActive.set(false)
+        shift.complete()
         val f: suspend () -> B = { error(e.nonFatalOrThrow()) }
         f.startCoroutineUninterceptedOrReturn(cont)
       }

From 2088deca065614ccc625a26de30d0c3c5ecb5513 Mon Sep 17 00:00:00 2001
From: Simon Vergauwen <nomisRev@users.noreply.github.com>
Date: Tue, 10 Jan 2023 14:40:57 +0100
Subject: [PATCH 15/15] Fix shift

---
 .../src/commonMain/kotlin/arrow/core/continuations/Effect.kt    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
index 56aa6386e13..e0e3e67f45d 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Effect.kt
@@ -804,7 +804,7 @@ internal class FoldContinuation<R, B>(
   // CancellationException and thus effectively recovering from the cancellation/shift.
   // This means try/catch is also capable of recovering from monadic errors.
     // See: EffectSpec - try/catch tests
-    if (complete()) throw Suspend(this, r, recover as suspend (Any?) -> Any?)
+    if (isActive.get()) throw Suspend(this, r, recover as suspend (Any?) -> Any?)
     else throw ShiftLeakedException()
 
   // In contrast to `createCoroutineUnintercepted this doesn't create a new ContinuationImpl