Performance optimizations

benchmark/src/main/scala/benchmark/ManyTasksBenchmark.scala

@@ -37,9 +37,9 @@ class ManyTasksBenchmark {
   @Benchmark
   def zioBenchmark(): Unit = {
     val completed = new AtomicInteger(0)
-    val runtime = Runtime.default
     (1 to tasks).foreach { _ =>
-      val zio = ZIO.succeed(simpleComputation).map(_ => completed.incrementAndGet())
+      val runtime = Runtime.default
+      val zio = ZIO.succeedBlocking(simpleComputation).map(_ => completed.incrementAndGet())
       Unsafe.unsafe(implicit u => runtime.unsafe.fork(zio))
     }
     waitForComplete(completed)

core/src/main/scala/rapid/Fiber.scala

@@ -2,40 +2,31 @@ package rapid
 
 import java.util.concurrent.atomic.AtomicLong
 import scala.concurrent.duration._
+import scala.util.{Failure, Success, Try}
 
 class Fiber[Return](val task: Task[Return]) extends Task[Return] {
-  private var result: Either[Throwable, Return] = _
-  private val thread = Thread
-    .ofVirtual()
-    .name(s"rapid-${Fiber.counter.incrementAndGet()}")
-    .start(() => try {
-      result = Right(task.sync())
-    } catch {
-      case t: Throwable => result = Left(t)
-    })
+  private var result: Try[Return] = _
+
+  private val thread = Thread.startVirtualThread(() => {
+    result = Try(task.sync())
+  })
 
   override protected def invoke(): Return = await()
 
   override def start(): Fiber[Return] = this
 
   override def await(): Return = {
     thread.join()
-    result match {
-      case Left(t) => throw t
-      case Right(r) => r
-    }
+    result.get
   }
 
-  override def attempt(): Either[Throwable, Return] = {
+  override def attempt(): Try[Return] = {
     thread.join()
     result
   }
 
   def await(duration: Duration): Option[Return] = if (thread.join(java.time.Duration.ofMillis(duration.toMillis))) {
-    result match {
-      case Left(t) => throw t
-      case Right(r) => Some(r)
-    }
+    Some(result.get)
   } else {
     None
   }

core/src/main/scala/rapid/Task.scala

@@ -1,6 +1,7 @@
 package rapid
 
 import scala.concurrent.duration.FiniteDuration
+import scala.util.Try
 
 /**
  * Represents a task that can be executed to produce a result of type `Return`.
@@ -43,7 +44,7 @@ trait Task[Return] extends Any {
    *
    * @return either the result of the task or an exception
    */
-  def attempt(): Either[Throwable, Return] = start().attempt()
+  def attempt(): Try[Return] = start().attempt()
 
   /**
    * Transforms the result of the task using the given function.