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 557b398e672..3f24402fe05 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
@@ -161,41 +161,42 @@ internal class Eager(val token: Token, val shifted: Any?, val recover: (Any?) ->
  * ```
  * <!--- KNIT example-eager-effect-02.kt -->
  */
-public inline fun <R, A> eagerEffect(crossinline f: suspend EagerEffectScope<R>.() -> A): EagerEffect<R, A> =
-  object : EagerEffect<R, A> {
-    override fun <B> fold(recover: (R) -> B, transform: (A) -> B): B {
-      val token = Token()
-      val eagerEffectScope =
-        object : EagerEffectScope<R> {
-          // Shift away from this Continuation by intercepting it, and completing it with
-          // ShiftCancellationException
-          // This is needed because this function will never yield a result,
-          // so it needs to be cancelled to properly support coroutine cancellation
-          override suspend fun <B> shift(r: R): B =
-          // Some interesting consequences of how Continuation Cancellation works in Kotlin.
-          // We have to throw CancellationException to signal the Continuation was cancelled, and we
-          // shifted away.
-          // This however also means that the user can try/catch shift and recover from the
-          // 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?)
-        }
-
-      return try {
-        suspend { transform(f(eagerEffectScope)) }
-          .startCoroutineUninterceptedOrReturn(Continuation(EmptyCoroutineContext) { result ->
-            result.getOrElse { throwable ->
-              if (throwable is Eager && token == throwable.token) {
-                throwable.recover(throwable.shifted) as B
-              } else throw throwable
-            }
-          }) as B
-      } catch (e: Eager) {
-        if (token == e.token) e.recover(e.shifted) as B
-        else throw e
+public fun <R, A> eagerEffect(f: suspend EagerEffectScope<R>.() -> A): EagerEffect<R, A> = DefaultEagerEffect(f)
+
+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 eagerEffectScope =
+      object : EagerEffectScope<R> {
+        // Shift away from this Continuation by intercepting it, and completing it with
+        // ShiftCancellationException
+        // This is needed because this function will never yield a result,
+        // so it needs to be cancelled to properly support coroutine cancellation
+        override suspend fun <B> shift(r: R): B =
+        // Some interesting consequences of how Continuation Cancellation works in Kotlin.
+        // We have to throw CancellationException to signal the Continuation was cancelled, and we
+        // shifted away.
+        // This however also means that the user can try/catch shift and recover from the
+        // 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?)
       }
+
+    return try {
+      suspend { transform(f(eagerEffectScope)) }
+        .startCoroutineUninterceptedOrReturn(Continuation(EmptyCoroutineContext) { result ->
+          result.getOrElse { throwable ->
+            if (throwable is Eager && token == throwable.token) {
+              throwable.recover(throwable.shifted) as B
+            } else throw throwable
+          }
+        }) as B
+    } catch (e: Eager) {
+      if (token == e.token) e.recover(e.shifted) as B
+      else throw e
     }
   }
+}
 
 private const val deprecateMonadAppFunctorOperators: String = "Operators related to Functor, Applicative or Monad hierarchies are being deprecated in favor of bind"
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 aefc254347d..ee493d3a488 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
@@ -752,38 +752,39 @@ internal class FoldContinuation<B>(
  * ```
  * <!--- KNIT example-effect-02.kt -->
  */
-public inline fun <R, A> effect(crossinline f: suspend EffectScope<R>.() -> A): Effect<R, A> =
-  object : Effect<R, A> {
-    // We create a `Token` for fold Continuation, so we can properly differentiate between nested
-    // folds
-    override suspend fun <B> fold(recover: suspend (R) -> B, transform: suspend (A) -> B): B =
-      suspendCoroutineUninterceptedOrReturn { cont ->
-        val token = Token()
-        val effectScope =
-          object : EffectScope<R> {
-            // Shift away from this Continuation by intercepting it, and completing it with
-            // ShiftCancellationException
-            // This is needed because this function will never yield a result,
-            // so it needs to be cancelled to properly support coroutine cancellation
-            override suspend fun <B> shift(r: R): B =
-            // Some interesting consequences of how Continuation Cancellation works in Kotlin.
-            // We have to throw CancellationException to signal the Continuation was cancelled, and we
-            // shifted away.
-            // This however also means that the user can try/catch shift and recover from the
-            // 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(token, r, recover as suspend (Any?) -> Any?)
-          }
+public fun <R, A> effect(f: suspend EffectScope<R>.() -> A): Effect<R, A> = DefaultEffect(f)
 
-        try {
-          suspend { transform(f(effectScope)) }
-            .startCoroutineUninterceptedOrReturn(FoldContinuation(token, cont.context, cont))
-        } catch (e: Suspend) {
-          if (token == e.token) {
-            val f: suspend () -> B = { e.recover(e.shifted) as B }
-            f.startCoroutineUninterceptedOrReturn(cont)
-          } else throw e
+private class DefaultEffect<R, A>(private val f: suspend EffectScope<R>.() -> A) : Effect<R, A> {
+  // We create a `Token` for fold Continuation, so we can properly differentiate between nested
+  // folds
+  override suspend fun <B> fold(recover: suspend (R) -> B, transform: suspend (A) -> B): B =
+    suspendCoroutineUninterceptedOrReturn { cont ->
+      val token = Token()
+      val effectScope =
+        object : EffectScope<R> {
+          // Shift away from this Continuation by intercepting it, and completing it with
+          // ShiftCancellationException
+          // This is needed because this function will never yield a result,
+          // so it needs to be cancelled to properly support coroutine cancellation
+          override suspend fun <B> shift(r: R): B =
+          // Some interesting consequences of how Continuation Cancellation works in Kotlin.
+          // We have to throw CancellationException to signal the Continuation was cancelled, and we
+          // shifted away.
+          // This however also means that the user can try/catch shift and recover from the
+          // 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(token, r, recover as suspend (Any?) -> Any?)
         }
+
+      try {
+        suspend { transform(f(effectScope)) }
+          .startCoroutineUninterceptedOrReturn(FoldContinuation(token, cont.context, cont))
+      } catch (e: Suspend) {
+        if (token == e.token) {
+          val f: suspend () -> B = { e.recover(e.shifted) as B }
+          f.startCoroutineUninterceptedOrReturn(cont)
+        } else throw e
       }
-  }
+    }
+}
diff --git a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/either.kt b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/either.kt
index c4e58d5a14c..a03b738ef37 100644
--- a/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/either.kt
+++ b/arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/either.kt
@@ -4,9 +4,9 @@ import arrow.core.Either
 
 @Suppress("ClassName")
 public object either {
-  public inline fun <E, A> eager(crossinline f: suspend EagerEffectScope<E>.() -> A): Either<E, A> =
+  public inline fun <E, A> eager(noinline f: suspend EagerEffectScope<E>.() -> A): Either<E, A> =
     eagerEffect(f).toEither()
 
-  public suspend inline operator fun <E, A> invoke(crossinline f: suspend EffectScope<E>.() -> A): Either<E, A> =
+  public suspend operator fun <E, A> invoke(f: suspend EffectScope<E>.() -> A): Either<E, A> =
     effect(f).toEither()
 }