Use Scala's new capture checking

build.sbt

@@ -1,7 +1,7 @@
 
 lazy val commonSettings = Seq(
     version := "0.1.0-SNAPSHOT",
-    scalaVersion := "3.3.1",
+    scalaVersion := "3.4.0-RC1-bin-20240105-d2cc3ae-NIGHTLY",
     // javaOptions ++= Seq(
     //   "-XX:-DetectLocksInCompiledFrames",
     //   "-XX:+UnlockDiagnosticVMOptions",

core/src/main/scala/monadic/examples/Capabilities.scala

@@ -92,7 +92,7 @@ object library {
     /**
      * Provide services to the computation, fully satisfying its requirements
      */
-    inline def provide(service: R): EFF[Any, E, A] = effectful { this.force()(using service) }
+    infix inline def provide(service: R): EFF[Any, E, A] = effectful { this.force()(using service) }
 
     inline def catchAll[R1 <: R, E1, A1 >: A](handler: E => Eff[R1, E1, A1]): EFF[R1, E1, A1] = effectful {
       try { this.force()(using use[R1], ()) }

core/src/main/scala/monadic/examples/Capture.scala

@@ -0,0 +1,91 @@
+package monadic
+package examples
+package capture
+
+import language.experimental.captureChecking
+
+
+object redesign extends App {
+
+  trait Effect {
+
+    /**
+     * The monadic type constructor
+     */
+    type M[A]
+
+    /**
+     * The Monad instance for [[ M ]]
+     */
+    def Monad: Monadic[M]
+
+    /**
+     * The interface of effect operations, supported by the monad
+     */
+    type Operations
+
+    /**
+     * Implementation of the effect operations in terms of monadic reflection.
+     */
+    def Operations: CanReflect[M] ?=> Operations
+
+    /**
+     * Runs a [[ program ]] that can make use of the effect [[ Operations ]]
+     * to compute a result of type [[ A ]] in monad [[ M ]].
+     */
+    def apply[A](program: Operations^ ?=> A): M[A] =
+      Monad.reify { cap ?=> program(using Operations) }
+
+    /**
+     * Makes the effect operations available on the effect instance
+     */
+    implicit inline def api(self: this.type)(using impl: Operations^): Operations^{impl} = impl
+  }
+
+
+  trait State[S] {
+    def get(): S
+    def set(s: S): Unit
+    def update(fn: S => S): Unit
+  }
+
+  class StateMonad[S] extends Effect {
+
+    type M[A] = S => (S, A)
+
+    class Operations(using CanReflect[M]) extends State[S] {
+      def get() = Monad.reflect(s => (s, s))
+      def set(s: S) = Monad.reflect(_ => (s, ()))
+      def update(fn: S => S) = Monad.reflect(s => (fn(s), ()))
+    }
+
+    def Operations = new Operations
+
+    class Monad extends Monadic[M] {
+      def pure[A](a: A): M[A] = s => (s, a)
+      def sequence[X, R](init: M[X])(f: X => Either[M[X], M[R]]): M[R] =
+        @scala.annotation.tailrec
+        def go(prog: M[X], state: S): (S, R) =
+          val (newState, x) = prog(state)
+          f(x) match {
+            case Left(mx) => go(mx, newState)
+            case Right(res) => res(newState)
+          }
+        s => go(init, s)
+    }
+    // with capture checking enabled, this cannot be defined by an object
+    val Monad = new Monad
+  }
+
+  object Number extends StateMonad[Int]
+
+  val result = Number {
+    while (Number.get() > 0) {
+      Number.set(Number.get() - 1)
+      //if (Number.get() == 1) throw new Exception("Abort!")
+    }
+  }
+  try { println(result(1000)) } catch {
+    case e: Exception => e.printStackTrace()
+  }
+}

core/src/main/scala/monadic/syntax.scala

@@ -1,14 +1,14 @@
 package monadic
 package syntax
 
-  type in[A, M[_]] = CanReflect[M] ?=> A
+  infix type in[A, M[_]] = CanReflect[M] ?=> A
 
   inline def reify[M[_]: Monadic]: ReifyBuilder[M] = ReifyBuilder()
 
   case class ReifyBuilder[M[_]]()(using M: Monadic[M]) {
-    inline def in[R](prog: R in M) = M.reify[R] { prog }
+    infix inline def in[R](prog: R in M) = M.reify[R] { prog }
     inline def apply[R](prog: R in M) = M.reify[R] { prog }
   }
 
   extension [M[_], R](mr: M[R])
-    inline def reflect(using r: CanReflect[M]): R = r.reflect(mr)
+    inline def reflect(using r: CanReflect[M]): R = r.reflect(mr)