diff --git a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Const.kt b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Const.kt
index 4c99a5bfdac..79cf889db76 100644
--- a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Const.kt
+++ b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Const.kt
@@ -5,9 +5,6 @@ import arrow.higherkind
 import arrow.typeclasses.Applicative
 import arrow.typeclasses.Semigroup
 import arrow.typeclasses.Show
-import arrow.typeclasses.suspended.BindSyntax
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
 
 fun <A, T> ConstOf<A, T>.value(): A = this.fix().value()
 
@@ -52,36 +49,3 @@ fun <T, A, G> ConstOf<A, Kind<G, T>>.sequence(GA: Applicative<G>): Kind<G, Const
 
 inline fun <A> A.const(): Const<A, Nothing> =
   Const(this)
-
-fun <A, T> const(c: suspend EagerBind<ConstPartialOf<A>>.() -> A): Const<A, T> {
-  val continuation: ConstContinuation<A, A> = ConstContinuation()
-  return continuation.startCoroutineUninterceptedAndReturn {
-    Const.just(c())
-  } as Const<A, T>
-}
-
-suspend fun <A, T> const(c: suspend BindSyntax<ConstPartialOf<A>>.() -> A): Const<A, T> =
-  suspendCoroutineUninterceptedOrReturn { cont ->
-    val continuation = ConstSContinuation(cont as Continuation<ConstOf<A, T>>)
-    continuation.startCoroutineUninterceptedOrReturn {
-      Const.just(c())
-    }
-  }
-
-internal class ConstSContinuation<A, T>(
-  parent: Continuation<ConstOf<A, T>>
-) : SuspendMonadContinuation<ConstPartialOf<A>, T>(parent) {
-  override fun ShortCircuit.recover(): Const<A, T> =
-    throw this
-
-  override suspend fun <B> Kind<ConstPartialOf<A>, B>.bind(): B =
-    value() as B
-}
-
-internal class ConstContinuation<A, T> : MonadContinuation<ConstPartialOf<A>, T>() {
-  override fun ShortCircuit.recover(): Const<A, T> =
-    throw this
-
-  override suspend fun <B> Kind<ConstPartialOf<A>, B>.bind(): B =
-    value() as B
-}
diff --git a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Either.kt b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Either.kt
index 7431eee94c2..494ff4c2927 100644
--- a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Either.kt
+++ b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Either.kt
@@ -5,9 +5,6 @@ import arrow.core.Either.Left
 import arrow.core.Either.Right
 import arrow.higherkind
 import arrow.typeclasses.Show
-import arrow.typeclasses.suspended.BindSyntax
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
 
 /**
  *
@@ -646,7 +643,7 @@ import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
  *
  * ```kotlin:ank:playground
  * import arrow.core.Either
- * import arrow.core.either
+ * import arrow.core.computations.either
  *
  * suspend fun main() {
  * val value =
@@ -673,7 +670,6 @@ import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
  * ```
  *
  */
-
 @higherkind
 sealed class Either<out A, out B> : EitherOf<A, B> {
 
@@ -1081,8 +1077,6 @@ inline fun <A, B> B?.rightIfNotNull(default: () -> A): Either<A, B> = when (this
 /**
  * Returns [Either.Right] if the value of type Any? is null, otherwise the specified A value wrapped into an
  * [Either.Left].
- *
- * ```
  */
 inline fun <A> Any?.rightIfNull(default: () -> A): Either<A, Nothing?> = when (this) {
   null -> Either.right(null)
@@ -1100,36 +1094,3 @@ inline fun <A, B> EitherOf<A, B>.handleErrorWith(f: (A) -> EitherOf<A, B>): Eith
       is Right -> it
     }
   }
-
-fun <E, A> either(c: suspend EagerBind<EitherPartialOf<E>>.() -> A): Either<E, A> {
-  val continuation: EitherContinuation<E, A> = EitherContinuation()
-  return continuation.startCoroutineUninterceptedAndReturn {
-    Right(c())
-  } as Either<E, A>
-}
-
-suspend fun <E, A> either(c: suspend BindSyntax<EitherPartialOf<E>>.() -> A): Either<E, A> =
-  suspendCoroutineUninterceptedOrReturn { cont ->
-    val continuation = EitherSContinuation(cont as Continuation<EitherOf<E, A>>)
-    continuation.startCoroutineUninterceptedOrReturn {
-      Right(c())
-    }
-  }
-
-internal class EitherSContinuation<E, A>(
-  parent: Continuation<EitherOf<E, A>>
-) : SuspendMonadContinuation<EitherPartialOf<E>, A>(parent) {
-  override fun ShortCircuit.recover(): Kind<EitherPartialOf<E>, A> =
-    Left(value as E)
-
-  override suspend fun <A> Kind<EitherPartialOf<E>, A>.bind(): A =
-    fix().fold({ e -> throw ShortCircuit(e) }, ::identity)
-}
-
-internal class EitherContinuation<E, A> : MonadContinuation<EitherPartialOf<E>, A>() {
-  override fun ShortCircuit.recover(): Kind<EitherPartialOf<E>, A> =
-    Left(value as E)
-
-  override suspend fun <A> Kind<EitherPartialOf<E>, A>.bind(): A =
-    fix().fold({ e -> throw ShortCircuit(e) }, ::identity)
-}
diff --git a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Eval.kt b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Eval.kt
index c2dac886c9e..e9b98b54d5a 100644
--- a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Eval.kt
+++ b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Eval.kt
@@ -1,10 +1,6 @@
 package arrow.core
 
-import arrow.Kind
 import arrow.higherkind
-import arrow.typeclasses.suspended.BindSyntax
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
 
 fun <A> EvalOf<A>.value(): A = this.fix().value()
 
@@ -367,36 +363,3 @@ fun <A, B> Iterator<A>.iterateRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Ev
     Eval.defer { if (this.hasNext()) f(this.next(), loop()) else lb }
   return loop()
 }
-
-fun <A> eval(c: suspend EagerBind<ForEval>.() -> A): Eval<A> {
-  val continuation: EvalContinuation<A> = EvalContinuation()
-  return continuation.startCoroutineUninterceptedAndReturn {
-    Eval.just(c())
-  } as Eval<A>
-}
-
-suspend fun <A> eval(c: suspend BindSyntax<ForEval>.() -> A): Eval<A> =
-  suspendCoroutineUninterceptedOrReturn { cont ->
-    val continuation = EvalSContinuation(cont as Continuation<EvalOf<A>>)
-    continuation.startCoroutineUninterceptedOrReturn {
-      Eval.just(c())
-    }
-  }
-
-internal class EvalSContinuation<A>(
-  parent: Continuation<EvalOf<A>>
-) : SuspendMonadContinuation<ForEval, A>(parent) {
-  override fun ShortCircuit.recover(): Kind<ForEval, A> =
-    throw this
-
-  override suspend fun <A> Kind<ForEval, A>.bind(): A =
-    fix().value()
-}
-
-internal class EvalContinuation<A> : MonadContinuation<ForEval, A>() {
-  override fun ShortCircuit.recover(): Kind<ForEval, A> =
-    throw this
-
-  override suspend fun <A> Kind<ForEval, A>.bind(): A =
-    fix().value()
-}
diff --git a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Validated.kt b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Validated.kt
index 58ffd9c46b4..352333c97ea 100644
--- a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Validated.kt
+++ b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/Validated.kt
@@ -5,9 +5,6 @@ import arrow.higherkind
 import arrow.typeclasses.Applicative
 import arrow.typeclasses.Semigroup
 import arrow.typeclasses.Show
-import arrow.typeclasses.suspended.BindSyntax
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
 
 typealias ValidatedNel<E, A> = Validated<Nel<E>, A>
 typealias Valid<A> = Validated.Valid<A>
@@ -142,7 +139,7 @@ typealias Invalid<E> = Validated.Invalid<E>
  * import arrow.core.Option
  * import arrow.core.Some
  * import arrow.core.Validated
- * import arrow.core.validated
+ * import arrow.core.computations.validated
  * import arrow.core.valid
  * import arrow.core.invalid
  *
@@ -244,7 +241,7 @@ typealias Invalid<E> = Validated.Invalid<E>
  * import arrow.core.Option
  * import arrow.core.Some
  * import arrow.core.Validated
- * import arrow.core.validated
+ * import arrow.core.computations.validated
  * import arrow.core.valid
  * import arrow.core.invalid
  * import arrow.core.NonEmptyList
@@ -311,7 +308,7 @@ typealias Invalid<E> = Validated.Invalid<E>
  * import arrow.core.Option
  * import arrow.core.Some
  * import arrow.core.Validated
- * import arrow.core.validated
+ * import arrow.core.computations.validated
  * import arrow.core.valid
  * import arrow.core.invalid
  * import arrow.core.NonEmptyList
@@ -385,7 +382,7 @@ typealias Invalid<E> = Validated.Invalid<E>
  * import arrow.core.right
  * import arrow.core.Some
  * import arrow.core.Validated
- * import arrow.core.validated
+ * import arrow.core.computations.validated
  * import arrow.core.valid
  * import arrow.core.invalid
  *
@@ -914,36 +911,3 @@ inline fun <A> A.validNel(): ValidatedNel<Nothing, A> =
 
 inline fun <E> E.invalidNel(): ValidatedNel<E, Nothing> =
   Validated.invalidNel(this)
-
-fun <E, A> validated(c: suspend EagerBind<ValidatedPartialOf<E>>.() -> A): Validated<E, A> {
-  val continuation: ValidatedContinuation<E, A> = ValidatedContinuation()
-  return continuation.startCoroutineUninterceptedAndReturn {
-    Valid(c())
-  } as Validated<E, A>
-}
-
-suspend fun <E, A> validated(c: suspend BindSyntax<ValidatedPartialOf<E>>.() -> A): Validated<E, A> =
-  suspendCoroutineUninterceptedOrReturn { cont ->
-    val continuation = ValidatedSContinuation(cont as Continuation<ValidatedOf<E, A>>)
-    continuation.startCoroutineUninterceptedOrReturn {
-      Valid(c())
-    }
-  }
-
-internal class ValidatedSContinuation<E, A>(
-  parent: Continuation<ValidatedOf<E, A>>
-) : SuspendMonadContinuation<ValidatedPartialOf<E>, A>(parent) {
-  override suspend fun <A> Kind<ValidatedPartialOf<E>, A>.bind(): A =
-    fix().fold({ e -> throw ShortCircuit(e) }, ::identity)
-
-  override fun ShortCircuit.recover(): Kind<ValidatedPartialOf<E>, A> =
-    Invalid(value as E)
-}
-
-internal class ValidatedContinuation<E, A> : MonadContinuation<ValidatedPartialOf<E>, A>() {
-  override suspend fun <A> Kind<ValidatedPartialOf<E>, A>.bind(): A =
-    fix().fold({ e -> throw ShortCircuit(e) }, ::identity)
-
-  override fun ShortCircuit.recover(): Kind<ValidatedPartialOf<E>, A> =
-    Invalid(value as E)
-}
diff --git a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/const.kt b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/const.kt
new file mode 100644
index 00000000000..afaad2ad789
--- /dev/null
+++ b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/const.kt
@@ -0,0 +1,49 @@
+package arrow.core.computations
+
+import arrow.Kind
+import arrow.core.Const
+import arrow.core.ConstOf
+import arrow.core.ConstPartialOf
+import arrow.core.EagerBind
+import arrow.core.MonadContinuation
+import arrow.core.ShortCircuit
+import arrow.core.SuspendMonadContinuation
+import arrow.core.value
+import arrow.typeclasses.suspended.BindSyntax
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
+
+object const {
+  fun <A, T> eager(c: suspend EagerBind<ConstPartialOf<A>>.() -> A): Const<A, T> {
+    val continuation: ConstContinuation<A, A> = ConstContinuation()
+    return continuation.startCoroutineUninterceptedAndReturn {
+      Const.just(c())
+    } as Const<A, T>
+  }
+
+  suspend operator fun <A, T> invoke(c: suspend BindSyntax<ConstPartialOf<A>>.() -> A): Const<A, T> =
+    suspendCoroutineUninterceptedOrReturn { cont ->
+      val continuation = ConstSContinuation(cont as Continuation<ConstOf<A, T>>)
+      continuation.startCoroutineUninterceptedOrReturn {
+        Const.just(c())
+      }
+    }
+
+  internal class ConstSContinuation<A, T>(
+    parent: Continuation<ConstOf<A, T>>
+  ) : SuspendMonadContinuation<ConstPartialOf<A>, T>(parent) {
+    override fun ShortCircuit.recover(): Const<A, T> =
+      throw this
+
+    override suspend fun <B> Kind<ConstPartialOf<A>, B>.bind(): B =
+      value() as B
+  }
+
+  internal class ConstContinuation<A, T> : MonadContinuation<ConstPartialOf<A>, T>() {
+    override fun ShortCircuit.recover(): Const<A, T> =
+      throw this
+
+    override suspend fun <B> Kind<ConstPartialOf<A>, B>.bind(): B =
+      value() as B
+  }
+}
diff --git a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/either.kt b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/either.kt
new file mode 100644
index 00000000000..a1748f3ea75
--- /dev/null
+++ b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/either.kt
@@ -0,0 +1,50 @@
+package arrow.core.computations
+
+import arrow.Kind
+import arrow.core.EagerBind
+import arrow.core.Either
+import arrow.core.EitherOf
+import arrow.core.EitherPartialOf
+import arrow.core.MonadContinuation
+import arrow.core.ShortCircuit
+import arrow.core.SuspendMonadContinuation
+import arrow.core.fix
+import arrow.core.identity
+import arrow.typeclasses.suspended.BindSyntax
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
+
+object either {
+  fun <E, A> eager(c: suspend EagerBind<EitherPartialOf<E>>.() -> A): Either<E, A> {
+    val continuation: EitherContinuation<E, A> = EitherContinuation()
+    return continuation.startCoroutineUninterceptedAndReturn {
+      Either.Right(c())
+    } as Either<E, A>
+  }
+
+  suspend operator fun <E, A> invoke(c: suspend BindSyntax<EitherPartialOf<E>>.() -> A): Either<E, A> =
+    suspendCoroutineUninterceptedOrReturn { cont ->
+      val continuation = EitherSContinuation(cont as Continuation<EitherOf<E, A>>)
+      continuation.startCoroutineUninterceptedOrReturn {
+        Either.Right(c())
+      }
+    }
+
+  internal class EitherSContinuation<E, A>(
+    parent: Continuation<EitherOf<E, A>>
+  ) : SuspendMonadContinuation<EitherPartialOf<E>, A>(parent) {
+    override fun ShortCircuit.recover(): Kind<EitherPartialOf<E>, A> =
+      Either.Left(value as E)
+
+    override suspend fun <A> Kind<EitherPartialOf<E>, A>.bind(): A =
+      fix().fold({ e -> throw ShortCircuit(e) }, ::identity)
+  }
+
+  internal class EitherContinuation<E, A> : MonadContinuation<EitherPartialOf<E>, A>() {
+    override fun ShortCircuit.recover(): Kind<EitherPartialOf<E>, A> =
+      Either.Left(value as E)
+
+    override suspend fun <A> Kind<EitherPartialOf<E>, A>.bind(): A =
+      fix().fold({ e -> throw ShortCircuit(e) }, ::identity)
+  }
+}
diff --git a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/eval.kt b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/eval.kt
new file mode 100644
index 00000000000..73cf72bcec2
--- /dev/null
+++ b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/eval.kt
@@ -0,0 +1,49 @@
+package arrow.core.computations
+
+import arrow.Kind
+import arrow.core.EagerBind
+import arrow.core.Eval
+import arrow.core.EvalOf
+import arrow.core.ForEval
+import arrow.core.MonadContinuation
+import arrow.core.ShortCircuit
+import arrow.core.SuspendMonadContinuation
+import arrow.core.fix
+import arrow.typeclasses.suspended.BindSyntax
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
+
+object eval {
+  fun <A> eager(c: suspend EagerBind<ForEval>.() -> A): Eval<A> {
+    val continuation: EvalContinuation<A> = EvalContinuation()
+    return continuation.startCoroutineUninterceptedAndReturn {
+      Eval.just(c())
+    } as Eval<A>
+  }
+
+  suspend operator fun <A> invoke(c: suspend BindSyntax<ForEval>.() -> A): Eval<A> =
+    suspendCoroutineUninterceptedOrReturn { cont ->
+      val continuation = EvalSContinuation(cont as Continuation<EvalOf<A>>)
+      continuation.startCoroutineUninterceptedOrReturn {
+        Eval.just(c())
+      }
+    }
+
+  internal class EvalSContinuation<A>(
+    parent: Continuation<EvalOf<A>>
+  ) : SuspendMonadContinuation<ForEval, A>(parent) {
+    override fun ShortCircuit.recover(): Kind<ForEval, A> =
+      throw this
+
+    override suspend fun <A> Kind<ForEval, A>.bind(): A =
+      fix().value()
+  }
+
+  internal class EvalContinuation<A> : MonadContinuation<ForEval, A>() {
+    override fun ShortCircuit.recover(): Kind<ForEval, A> =
+      throw this
+
+    override suspend fun <A> Kind<ForEval, A>.bind(): A =
+      fix().value()
+  }
+}
diff --git a/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/validated.kt b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/validated.kt
new file mode 100644
index 00000000000..e1a66ab7363
--- /dev/null
+++ b/arrow-libs/core/arrow-core-data/src/main/kotlin/arrow/core/computations/validated.kt
@@ -0,0 +1,52 @@
+package arrow.core.computations
+
+import arrow.Kind
+import arrow.core.EagerBind
+import arrow.core.Invalid
+import arrow.core.MonadContinuation
+import arrow.core.ShortCircuit
+import arrow.core.SuspendMonadContinuation
+import arrow.core.Valid
+import arrow.core.Validated
+import arrow.core.ValidatedOf
+import arrow.core.ValidatedPartialOf
+import arrow.core.fix
+import arrow.core.identity
+import arrow.typeclasses.suspended.BindSyntax
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
+
+object validated {
+  fun <E, A> eager(c: suspend EagerBind<ValidatedPartialOf<E>>.() -> A): Validated<E, A> {
+    val continuation: ValidatedContinuation<E, A> = ValidatedContinuation()
+    return continuation.startCoroutineUninterceptedAndReturn {
+      Valid(c())
+    } as Validated<E, A>
+  }
+
+  suspend operator fun <E, A> invoke(c: suspend BindSyntax<ValidatedPartialOf<E>>.() -> A): Validated<E, A> =
+    suspendCoroutineUninterceptedOrReturn { cont ->
+      val continuation = ValidatedSContinuation(cont as Continuation<ValidatedOf<E, A>>)
+      continuation.startCoroutineUninterceptedOrReturn {
+        Valid(c())
+      }
+    }
+
+  internal class ValidatedSContinuation<E, A>(
+    parent: Continuation<ValidatedOf<E, A>>
+  ) : SuspendMonadContinuation<ValidatedPartialOf<E>, A>(parent) {
+    override suspend fun <A> Kind<ValidatedPartialOf<E>, A>.bind(): A =
+      fix().fold({ e -> throw ShortCircuit(e) }, ::identity)
+
+    override fun ShortCircuit.recover(): Kind<ValidatedPartialOf<E>, A> =
+      Invalid(value as E)
+  }
+
+  internal class ValidatedContinuation<E, A> : MonadContinuation<ValidatedPartialOf<E>, A>() {
+    override suspend fun <A> Kind<ValidatedPartialOf<E>, A>.bind(): A =
+      fix().fold({ e -> throw ShortCircuit(e) }, ::identity)
+
+    override fun ShortCircuit.recover(): Kind<ValidatedPartialOf<E>, A> =
+      Invalid(value as E)
+  }
+}
diff --git a/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/ConstTest.kt b/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/ConstTest.kt
index 32b5289361e..6ad68a8d3c4 100644
--- a/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/ConstTest.kt
+++ b/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/ConstTest.kt
@@ -1,6 +1,7 @@
 package arrow.core
 
 import arrow.Kind
+import arrow.core.computations.const
 import arrow.core.extensions.const.applicative.applicative
 import arrow.core.extensions.const.eq.eq
 import arrow.core.extensions.const.functor.functor
@@ -41,7 +42,7 @@ class ConstTest : UnitSpec() {
         ApplicativeLaws.laws(Const.applicative(M), Const.functor(), GENK, EQK),
         EqLaws.laws(Const.eq<Int, Int>(Eq.any()), GEN),
         ShowLaws.laws(Const.show(Int.show()), Const.eq<Int, Int>(Eq.any()), GEN),
-        FxLaws.laws<ConstPartialOf<Int>, Int>(GENK.genK(Gen.int()), GENK.genK(Gen.int()), EQK.liftEq(Int.eq()), ::const, ::const)
+        FxLaws.laws<ConstPartialOf<Int>, Int>(GENK.genK(Gen.int()), GENK.genK(Gen.int()), EQK.liftEq(Int.eq()), const::eager, const::invoke)
       )
   }
 }
diff --git a/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/EitherTest.kt b/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/EitherTest.kt
index 9cb557cb48b..96f7193a2b9 100644
--- a/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/EitherTest.kt
+++ b/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/EitherTest.kt
@@ -1,9 +1,9 @@
 package arrow.core
 
 import arrow.Kind
+import arrow.core.computations.either
 import arrow.core.extensions.combine
 import arrow.core.extensions.either.applicative.applicative
-import arrow.core.extensions.either.applicativeError.handleErrorWith
 import arrow.core.extensions.either.bicrosswalk.bicrosswalk
 import arrow.core.extensions.either.bifunctor.bifunctor
 import arrow.core.extensions.either.bitraverse.bitraverse
@@ -71,7 +71,7 @@ class EitherTest : UnitSpec() {
       SemigroupKLaws.laws(Either.semigroupK(), Either.genK(Gen.id(Gen.int())), Either.eqK(Id.eq(Int.eq()))),
       HashLaws.laws(Either.hash(String.hash(), Int.hash()), GEN, Either.eq(String.eq(), Int.eq())),
       BicrosswalkLaws.laws(Either.bicrosswalk(), Either.genK2(), Either.eqK2()),
-      FxLaws.laws<EitherPartialOf<String>, Int>(Gen.int().map(::Right), GEN.map { it }, Either.eqK(String.eq()).liftEq(Int.eq()), ::either, ::either)
+      FxLaws.laws<EitherPartialOf<String>, Int>(Gen.int().map(::Right), GEN.map { it }, Either.eqK(String.eq()).liftEq(Int.eq()), either::eager, either::invoke)
     )
 
     "fromNullable should lift value as a Right if it is not null" {
diff --git a/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/EvalTest.kt b/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/EvalTest.kt
index e112ce12d22..68800d27438 100644
--- a/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/EvalTest.kt
+++ b/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/EvalTest.kt
@@ -1,6 +1,7 @@
 package arrow.core
 
 import arrow.Kind
+import arrow.core.computations.eval
 import arrow.core.extensions.eq
 import arrow.core.extensions.eval.applicative.applicative
 import arrow.core.extensions.eval.bimonad.bimonad
@@ -38,7 +39,7 @@ class EvalTest : UnitSpec() {
 
     testLaws(
       BimonadLaws.laws(Eval.bimonad(), Eval.monad(), Eval.comonad(), Eval.functor(), Eval.applicative(), Eval.monad(), GENK, EQK),
-      FxLaws.laws<ForEval, Int>(G, G, EQK.liftEq(Int.eq()), ::eval, ::eval)
+      FxLaws.laws<ForEval, Int>(G, G, EQK.liftEq(Int.eq()), eval::eager, eval::invoke)
     )
 
     "should map wrapped value" {
diff --git a/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/ValidatedTest.kt b/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/ValidatedTest.kt
index 2bcbac3f0f8..ffc511efebe 100644
--- a/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/ValidatedTest.kt
+++ b/arrow-libs/core/arrow-core-data/src/test/kotlin/arrow/core/ValidatedTest.kt
@@ -1,5 +1,6 @@
 package arrow.core
 
+import arrow.core.computations.validated
 import arrow.core.extensions.eq
 import arrow.core.extensions.monoid
 import arrow.core.extensions.semigroup
@@ -60,7 +61,7 @@ class ValidatedTest : UnitSpec() {
         Validated.genK2(),
         Validated.eqK2()
       ),
-      FxLaws.laws<ValidatedPartialOf<String>, Int>(Gen.int().map(::Valid), Gen.validated(Gen.string(), Gen.int()).map { it }, Validated.eqK(String.eq()).liftEq(Int.eq()), ::validated, ::validated)
+      FxLaws.laws<ValidatedPartialOf<String>, Int>(Gen.int().map(::Valid), Gen.validated(Gen.string(), Gen.int()).map { it }, Validated.eqK(String.eq()).liftEq(Int.eq()), validated::eager, validated::invoke)
     )
 
     "fold should call function on Invalid" {
diff --git a/arrow-libs/core/arrow-core/src/main/kotlin/arrow/core/extensions/either.kt b/arrow-libs/core/arrow-core/src/main/kotlin/arrow/core/extensions/either.kt
index dde825c562e..aa30b985b37 100644
--- a/arrow-libs/core/arrow-core/src/main/kotlin/arrow/core/extensions/either.kt
+++ b/arrow-libs/core/arrow-core/src/main/kotlin/arrow/core/extensions/either.kt
@@ -254,7 +254,7 @@ interface EitherHash<L, R> : Hash<Either<L, R>>, EitherEq<L, R> {
 }
 
 @Deprecated("Fx blocks are now named based on each datatype, please use `either { }` instead",
-  replaceWith = ReplaceWith("either(c)"))
+  replaceWith = ReplaceWith("either.eager<L, R>(c)"))
 fun <L, R> Either.Companion.fx(c: suspend MonadSyntax<EitherPartialOf<L>>.() -> R): Either<L, R> =
   Either.monad<L>().fx.monad(c).fix()
 
diff --git a/arrow-libs/core/arrow-core/src/main/kotlin/arrow/core/extensions/eval.kt b/arrow-libs/core/arrow-core/src/main/kotlin/arrow/core/extensions/eval.kt
index 5a55dd64bf5..6f661714a14 100644
--- a/arrow-libs/core/arrow-core/src/main/kotlin/arrow/core/extensions/eval.kt
+++ b/arrow-libs/core/arrow-core/src/main/kotlin/arrow/core/extensions/eval.kt
@@ -90,7 +90,7 @@ interface EvalBimonad : Bimonad<ForEval> {
   override fun <A, B> EvalOf<A>.flatMap(f: (A) -> EvalOf<B>): Eval<B> =
     fix().flatMap(f)
 
-  override fun <A, B> tailRecM(a: A, f: kotlin.Function1<A, EvalOf<Either<A, B>>>): Eval<B> =
+  override fun <A, B> tailRecM(a: A, f: (A) -> EvalOf<Either<A, B>>): Eval<B> =
     Eval.tailRecM(a, f)
 
   override fun <A, B> EvalOf<A>.map(f: (A) -> B): Eval<B> =
@@ -107,6 +107,6 @@ interface EvalBimonad : Bimonad<ForEval> {
 }
 
 @Deprecated("Fx blocks are now named based on each datatype, please use `eval { }` instead",
-  replaceWith = ReplaceWith("eval(c)"))
+  replaceWith = ReplaceWith("eval.eager(c)"))
 fun <B> Eval.Companion.fx(c: suspend MonadSyntax<ForEval>.() -> B): Eval<B> =
   defer { Eval.monad().fx.monad(c).fix() }