more tests, one failing

Author: lbialy

core/src/main/scala/ox/either.scala

@@ -7,6 +7,9 @@ import scala.util.control.NonFatal
 import scala.util.NotGiven
 
 object either:
+  /** This technique allows to prevent implicit search from finding the givens thanks to ambiguity. In the scope that returns `A` it will be
+    * impossible to find a given [[Supervised]] and [[Forked]].
+    */
   private type WithoutScopeMarkers[A] = (Supervised, Supervised) ?=> (Forked, Forked) ?=> A
 
   private inline def availableInScope[A]: Boolean =
@@ -15,18 +18,18 @@ object either:
       case _: A           => true
     }
 
-  /** Within an [[either]] block, allows unwrapping [[Either]] and [[Option]] values using [[ok()]]. The result is the right-value of an
+  /** Within an [[either]] block, allows unwrapping [[Either]] and [[Option]] values using [[#ok()]]. The result is the right-value of an
     * `Either`, or the defined-value of the `Option`. In case a failure is encountered (a left-value of an `Either`, or a `None`), the
-    * computation is short-circuited and the failure becomes the result. Failures can also be reported using [[fail()]].
+    * computation is short-circuited and the failure becomes the result. Failures can also be reported using [[#fail()]].
     *
     * Uses the [[boundary]]-break mechanism.
     *
-    * Uses ambiguity-based given removal technique (given't) to enable usage of [[ok()]] combinator in [[either]] blocks nested inside
+    * Uses ambiguity-based given removal technique (given't) to enable usage of [[#ok()]] combinator in [[either]] blocks nested inside
     * [[ox.fork]] blocks.
     *
     * @param body
-    *   The code block, within which [[Either]]s and [[Option]]s can be unwrapped using [[ok()]]. Failures can be reported using [[fail()]].
-    *   Both [[ok()]] and [[fail()]] are extension methods.
+    *   The code block, within which [[Either]]s and [[Option]]s can be unwrapped using [[#ok()]]. Failures can be reported using
+    *   [[#fail()]]. Both [[#ok()]] and [[#fail()]] are extension methods.
     * @tparam E
     *   The error type.
     * @tparam A
@@ -46,7 +49,7 @@ object either:
     */
   inline def apply[E, A](inline body: WithoutScopeMarkers[Label[Either[E, A]] ?=> A]): Either[E, A] =
     given Forked = ForkedEvidence // just to satisfy the context function
-    given Supervised = SupervisedEvidence // just to satisfy the context function
+    given Supervised = SupervisedEvidence
     boundary(Right(body))
 
   extension [E, A](inline t: Either[E, A])
@@ -58,54 +61,54 @@ object either:
         error(
           "This use of .ok() belongs to either block outside of the fork and is therefore illegal. Use either block inside of the forked block."
         )
-
-      summonFrom {
-        case given boundary.Label[Either[E, Nothing]] =>
-          t match
-            case Left(e)  => break(Left(e))
-            case Right(a) => a
-        case given boundary.Label[Either[Nothing, Nothing]] =>
-          error("The enclosing `either` call uses a different error type.\nIf it's explicitly typed, is the error type correct?")
-        case _ => error("`.ok()` can only be used within an `either` call.\nIs it present?")
-      }
+      else
+        summonFrom {
+          case given boundary.Label[Either[E, Nothing]] =>
+            t match
+              case Left(e)  => break(Left(e))
+              case Right(a) => a
+          case given boundary.Label[Either[Nothing, Nothing]] =>
+            error("The enclosing `either` call uses a different error type.\nIf it's explicitly typed, is the error type correct?")
+          case _ => error("`.ok()` can only be used within an `either` call.\nIs it present?")
+        }
 
   extension [A](inline t: Option[A])
     /** Unwrap the value of the `Option`, short-circuiting the computation to the enclosing [[either]], in case this is a `None`. Can't be
       * used in forked blocks without an either block in fork to prevent escaped Breaks that crash forked threads.
       */
     transparent inline def ok(): A =
-      inline if availableInScope[Forked] then
+      inline if availableInScope[Forked] && !availableInScope[Supervised] then
         error(
           "This use of .ok() belongs to either block outside of the fork and is therefore illegal. Use either block inside of the forked block."
         )
-
-      summonFrom {
-        case given boundary.Label[Either[Unit, Nothing]] =>
-          t match
-            case None    => break(Left(()))
-            case Some(a) => a
-        case given boundary.Label[Either[Nothing, Nothing]] =>
-          error(
-            "The enclosing `either` call uses a different error type.\nIf it's explicitly typed, is the error type correct?\nNote that for options, the error type must contain a `Unit`."
-          )
-        case _ => error("`.ok()` can only be used within an `either` call.\nIs it present?")
-      }
+      else
+        summonFrom {
+          case given boundary.Label[Either[Unit, Nothing]] =>
+            t match
+              case None    => break(Left(()))
+              case Some(a) => a
+          case given boundary.Label[Either[Nothing, Nothing]] =>
+            error(
+              "The enclosing `either` call uses a different error type.\nIf it's explicitly typed, is the error type correct?\nNote that for options, the error type must contain a `Unit`."
+            )
+          case _ => error("`.ok()` can only be used within an `either` call.\nIs it present?")
+        }
 
   extension [E](e: E)
     /** Fail the computation by short-circuiting the enclosing [[either]] block with en error of type `E`. Can't be used in forked blocks
       * without an either block in fork to prevent escaped Breaks that crash forked threads.
       */
     transparent inline def fail(): Nothing =
-      inline if availableInScope[Forked] then
+      inline if availableInScope[Forked] && !availableInScope[Supervised] then
         error(
           "This use of .ok() belongs to either block outside of the fork and is therefore illegal. Use either block inside of the forked block."
         )
-
-      summonFrom {
-        case given boundary.Label[Either[E, Nothing]] => break(Left(e))
-        case given boundary.Label[Either[Nothing, Nothing]] =>
-          error("The enclosing `either` call uses a different error type.\nIf it's explicitly typed, is the error type correct?")
-      }
+      else
+        summonFrom {
+          case given boundary.Label[Either[E, Nothing]] => break(Left(e))
+          case given boundary.Label[Either[Nothing, Nothing]] =>
+            error("The enclosing `either` call uses a different error type.\nIf it's explicitly typed, is the error type correct?")
+        }
 
 /** Catches non-fatal exceptions that occur when evaluating `t` and returns them as the left side of the returned `Either`. */
 inline def catching[T](inline t: => T): Either[Throwable, T] =

core/src/test/scala/ox/ForkEitherInteropTest.scala

@@ -2,15 +2,15 @@ package ox
 
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
-import scala.compiletime.testing.typeCheckErrors
+import scala.compiletime.testing.*
 
 class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
 
   "forkUnsupervised" should "prevent usage of either.ok() combinator" in {
     assertReceivesForkedScopeError(
       """import ox.*
          import ox.either.*
-         
+
          val e1: Either[Throwable, Unit] = Left(Exception("uh oh"))
          unsupervised {
           either {
@@ -142,7 +142,8 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
     }
   }
 
-  "either in fork" should "allow usage of either.ok() combinator" in {
+  // empty line at the beginning of every snippet left to improve error reporting readability, do not remove
+  "fork/either interop" should "compile correct combinations" in {
     """
     import ox.*
     import ox.either.*
@@ -158,6 +159,140 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
       }
     }
     """ should compile
+
+    """
+       import ox.*
+       import ox.either.*
+
+       supervised {
+         either {
+           fork {
+             1
+           }
+         }
+       }""" should compile
+
+    """
+       import ox.*
+       import ox.either.*
+
+       either {
+         supervised {
+           fork {
+             Right(1).ok()
+           }
+         }
+       }""" should compile
+
+    """
+       import ox.*
+       import ox.either.*
+
+       supervised {
+         fork {
+           either {
+             Right(1).ok()
+           }
+         }
+       }""" should compile
+
+    """
+       import ox.*
+       import ox.either.*
+
+       either {
+         supervised {
+           fork {
+             supervised {
+               Right(1).ok()
+             }
+           }
+         }
+       }""" should compile
+
+    """
+       import ox.*
+       import ox.either.*
+
+       either {
+         supervised {
+           fork {
+             supervised {
+               fork {
+                 Right(1).ok()
+               }
+             }
+           }
+         }
+       }""" should compile
+
+    """
+       import ox.*
+       import ox.either.*
+
+       either {
+         supervised {
+           fork {
+             fork {
+               Right(1).ok()
+             }
+           }
+         }
+       }""" should compile
+  }
+
+  "fork/either interop" should "fail to compile invalid examples" in {
+    """
+       import ox.*
+       import ox.either.*
+
+       supervised {
+         either {
+           fork {
+             Right(1).ok()
+           }
+         }
+       }""" shouldNot compile
+
+    """
+       import ox.*
+       import ox.either.*
+
+       supervised {
+         fork {
+           either {
+             fork {
+               Right(1).ok()
+             }
+           }
+         }
+       }""" shouldNot compile
+
+    """
+       import ox.*
+       import ox.either.*
+
+       supervised {
+         either {
+           fork {
+             Right(1).ok()
+           }
+         }
+       }""" shouldNot compile
+
+    """
+       import ox.*
+       import ox.either.*
+
+       supervised { // Supervised ?=>
+         either { // Label ?=>
+           fork { // Forked ?=>
+             supervised { // Supervised ?=>
+               Right(1).ok() // if forked && !supervised then error but it is forked and then supervised
+             }
+           }
+         }
+       }""" shouldNot compile
   }
 
   "fork/either interop" should "work with either scopes nested in forks" in {
@@ -207,4 +342,5 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
           "This use of .ok() belongs to either block outside of the fork and is therefore illegal. Use either block inside of the forked block."
         )
     then throw Exception(errs.mkString("\n"))
+
 }