steps evalutator trait

Author: bishabosha

src/main/scala/steps/result/package.scala

@@ -10,6 +10,7 @@ import scala.util.boundary
 import scala.annotation.implicitNotFound
 import scala.Conversion.into
 import scala.util.boundary.Label
+import steps.result.Result.eval.break
 
 /** Represents either a success value of type `T` or an error of type `E`. It
   * can be used when expecting results that have errors that should be inspected
@@ -457,6 +458,51 @@ object Result:
 
   // Boundary and break
 
+  trait Evaluator[Impl[+_,+_]]:
+    self =>
+    type Success[+T]
+    type Failure[+E]
+
+    inline def foldValue[T, E](impl: Impl[T, E])[U](inline onSuccess: T => U, inline onFailure: Failure[E] => U): U
+    inline def failure[E](error: E): Failure[E]
+
+    extension [T, E](
+        using @implicitNotFound(
+          "`break` cannot be used outside of the `Result.apply` scope."
+        )
+        label: boundary.Label[Failure[E]])(impl: into[Impl[T, E]]) {
+          final inline def ok: T = foldValue(impl)(t => t, boundary.break(_))
+        }
+
+  trait EvaluatorCompanion[Impl[+_,+_]]:
+
+    final inline def raise[E](using eval: Evaluator[Impl])(using
+        @implicitNotFound(
+          "`raise` cannot be used outside of the `Result.apply` scope."
+        )
+        label: boundary.Label[eval.Failure[E]]
+    )(inline err: into[E]): Nothing = boundary.break(eval.failure(err))
+
+    final inline def break[T, E](using eval: Evaluator[Impl])(using
+        @implicitNotFound(
+          "`break` cannot be used outside of the `Result.apply` scope."
+        )
+        label: boundary.Label[Impl[T, E]]
+    )(inline res: into[Impl[T, E]]): Nothing = boundary.break(res)
+
+  given resultEvaluator: Evaluator[Result] with
+    type Success[T] = Ok[T]
+    type Failure[E] = Err[E]
+
+    inline def foldValue[T, E](impl: Result[T, E])[U](inline onSuccess: T => U, inline onFailure: Err[E] => U): U =
+      impl match
+        case Ok(value)  => onSuccess(value)
+        case err: Err[E] => onFailure(err)
+
+    inline def failure[E](error: E): Err[E] = Err(error)
+
+  object eval2 extends EvaluatorCompanion[Result]
+
   // Currently under its own object `eval` due to https://github.com/scala/scala3/issues/20126
 
   /** Evaluates `body`, returning the output as an [[Ok]] value.

src/test/scala/steps/result/Result.scala

@@ -3,8 +3,10 @@ import scala.util.Try
 import language.experimental.captureChecking
 
 import steps.result.Result
-import steps.result.Result.*
-import steps.result.Result.eval.*
+import steps.result.Result.{eval as _, *}
+// import steps.result.Result.eval.*
+
+import steps.result.Result.eval2.*
 
 class ResultTest extends munit.FunSuite {
 
@@ -165,12 +167,12 @@ class ResultTest extends munit.FunSuite {
 
     def log2(input: Int): Result[Int, LogErr] =
       Result:
-        if input < 1 then eval.raise(NoLog)
+        if input < 1 then eval2.raise(NoLog)
         else if input == 1 then 0
         else log2(input / 2).ok + 1
 
     Result[Int, Exception]: label ?=>
-      log2(5).ok
+      Result.resultEvaluator.ok(log2(5))//.ok
 
     assertEquals(log2(4), Ok(2))
     assertEquals(log2(-1), Err(LogErr.NL(NoLog)))
@@ -208,15 +210,15 @@ class ResultTest extends munit.FunSuite {
           case Seq() => init
           case Seq(h, t*) =>
             val next = f(init, h).ok
-            eval.break(tryFoldLeft(next, f)(t))
+            eval2.break(tryFoldLeft(next, f)(t))
   }
 
   test("implicit upcasting") {
     import steps.result.Conversions.Lift.given
 
     Result[Int, Nothing]:
       val t: Result[Int, String] = 1
-      eval.break(1)
+      eval2.break(1)
   }
 
   test("iterable") {
@@ -249,7 +251,7 @@ class ResultTest extends munit.FunSuite {
     Result[Int, Bar]: l1 ?=>
       Result[String, Foo]: l2 ?=>
         val r: Result[String, Int] = Result.Err(1)
-        val str: String = eval.ok(using l1)(r)
+        val str: String = eval2.ok(using l1)(r)
         str
       .ok.length
   }
@@ -259,7 +261,7 @@ class ResultTest extends munit.FunSuite {
   test("break error") {
     given Conversion[String, Int] = _.length // comment for failure
     Result[Int, Int]:
-      val z = eval.break(err)
+      val z = eval2.break(err)
       1
   }