Added orDie

getkyo · fwbrasil · Dec 7, 2024 · Dec 5, 2024 · Dec 5, 2024 · Dec 5, 2024
commit 58ed90b1ebacb0f51e5de9febe4e7db4db32fff2
diff --git a/kyo-combinators/shared/src/main/scala/kyo/Combinators.scala b/kyo-combinators/shared/src/main/scala/kyo/Combinators.scala
@@ -6,6 +6,8 @@ import kyo.kernel.Reducible
 import scala.annotation.tailrec
 import scala.annotation.targetName
 
+sealed class PanicException[A](val error: A) extends Exception(s"Uncaught error: $error")
+
 extension [A, S](effect: A < S)
 
     /** Performs this computation and then the next one, discarding the result of this computation.
@@ -386,6 +388,25 @@ extension [A, S, E](effect: A < (Abort[E] & S))
     ): A < (S & reduce.SReduced) =
         Abort.run[Throwable](effect.asInstanceOf[A < (Abort[Throwable | ER] & S)])
             .map(_.fold(e => throw e.getFailure)(identity))
+
+    /** Catches any Aborts and panics instead
+      *
+      * @return
+      *   A computation that panics instead of catching Abort effect failures
+      */
+    def orDie(
+        using
+        ct: SafeClassTag[E],
+        tag: Tag[E],
+        fl: Flat[A],
+        frame: Frame
+    ): A < S =
+        Abort.run[E](effect).map(
+            _.fold(_.getFailure match
+                case thr: Throwable => throw thr
+                case other          => throw PanicException(other)
+            )(identity)
+        )
 end extension
 
 extension [A, S, E](effect: A < (Abort[Absent] & S))

diff --git a/kyo-combinators/shared/src/test/scala/kyo/AbortCombinatorTest.scala b/kyo-combinators/shared/src/test/scala/kyo/AbortCombinatorTest.scala
@@ -343,6 +343,42 @@ class AbortCombinatorTest extends Test:
                 assert(Abort.run[Any](swapped3).eval == Result.fail(42))
             }
         }
+
+        "orDie" - {
+            "should remove Abort effects and run successfully if effect has no failures" in {
+                val effect: Int < Abort[String] =
+                    for
+                        i      <- (1: Int < Any)
+                        result <- if i > 1 then Abort.fail("error") else (i: Int < Any)
+                    yield i
+
+                val effectOrDie: Int < Any = effect.orDie
+                assert(effectOrDie.eval == 1)
+            }
+
+            "should remove throwable Abort and throw error" in {
+                val effect: Int < Abort[Throwable] =
+                    Abort.fail(IndexOutOfBoundsException()).map(_ => 23)
+
+                assertThrows[IndexOutOfBoundsException]:
+                    effect.orDie
+            }
+
+            "should remove non-throwable Abort and throw PanicException" in {
+                val effect: Int < Abort[String] =
+                    Abort.fail("error").map(_ => 23)
+
+                try
+                    val result: Int < Any = effect.orDie
+                    assert(???)
+                catch
+                    case err: PanicException[?] =>
+                        assert(err.error == "error")
+                    case other =>
+                        fail(s"unexpected exception: $other")
+                end try
+            }
+        }
     }
 
 end AbortCombinatorTest