[core] rename Sync.Unsafe.apply to Sync.Unsafe.defer (#1466)

I changed `Sync.apply` to `Sync.defer` some time ago but forgot to
rename `Sync.Unsafe.apply` as well.

Author: fwbrasil

kyo-cats/shared/src/main/scala/kyo/Cats.scala

@@ -16,7 +16,7 @@ object Cats:
       *   A Kyo effect that, when run, will execute the cats.effect.IO
       */
     def get[A](io: => CatsIO[A])(using Frame): A < (Abort[Nothing] & Async) =
-        Sync.Unsafe {
+        Sync.Unsafe.defer {
             import cats.effect.unsafe.implicits.global
             val p                = Promise.Unsafe.init[A, Any]()
             val (future, cancel) = io.unsafeToFutureCancelable()

kyo-core/jvm-native/src/main/scala/kyo/internal/AsyncPlatformSpecific.scala

@@ -9,7 +9,7 @@ private[kyo] class AsyncPlatformSpecific:
         fromCompletionStage(cs)
 
     def fromCompletionStage[A](cs: CompletionStage[A])(using Frame): A < Async =
-        Sync.Unsafe {
+        Sync.Unsafe.defer {
             val p = Promise.Unsafe.init[A, Any]()
             cs.whenComplete { (success, error) =>
                 if error == null then p.completeDiscard(Result.succeed(success))

kyo-core/shared/src/main/scala/kyo/Adder.scala

@@ -36,7 +36,7 @@ final case class LongAdder private (unsafe: LongAdder.Unsafe):
       * @return
       *   Unit
       */
-    inline def add(v: Long)(using inline frame: Frame): Unit < Sync = Sync.Unsafe(unsafe.add(v))
+    inline def add(v: Long)(using inline frame: Frame): Unit < Sync = Sync.Unsafe.defer(unsafe.add(v))
 
     /** Decrements the sum by one.
       *
@@ -45,7 +45,7 @@ final case class LongAdder private (unsafe: LongAdder.Unsafe):
       * @return
       *   Unit
       */
-    inline def decrement(using inline frame: Frame): Unit < Sync = Sync.Unsafe(unsafe.decrement())
+    inline def decrement(using inline frame: Frame): Unit < Sync = Sync.Unsafe.defer(unsafe.decrement())
 
     /** Increments the sum by one.
       *
@@ -54,7 +54,7 @@ final case class LongAdder private (unsafe: LongAdder.Unsafe):
       * @return
       *   Unit
       */
-    inline def increment(using inline frame: Frame): Unit < Sync = Sync.Unsafe(unsafe.increment())
+    inline def increment(using inline frame: Frame): Unit < Sync = Sync.Unsafe.defer(unsafe.increment())
 
     /** Returns the current sum.
       *
@@ -64,7 +64,7 @@ final case class LongAdder private (unsafe: LongAdder.Unsafe):
       * @return
       *   The current sum
       */
-    inline def get(using inline frame: Frame): Long < Sync = Sync.Unsafe(unsafe.get())
+    inline def get(using inline frame: Frame): Long < Sync = Sync.Unsafe.defer(unsafe.get())
 
     /** Resets the sum to zero.
       *
@@ -73,7 +73,7 @@ final case class LongAdder private (unsafe: LongAdder.Unsafe):
       * @return
       *   Unit
       */
-    inline def reset(using inline frame: Frame): Unit < Sync = Sync.Unsafe(unsafe.reset())
+    inline def reset(using inline frame: Frame): Unit < Sync = Sync.Unsafe.defer(unsafe.reset())
 
     /** Returns the current sum and resets it to zero.
       *
@@ -83,7 +83,7 @@ final case class LongAdder private (unsafe: LongAdder.Unsafe):
       * @return
       *   The sum before reset,
       */
-    inline def sumThenReset(using inline frame: Frame): Long < Sync = Sync.Unsafe(unsafe.sumThenReset())
+    inline def sumThenReset(using inline frame: Frame): Long < Sync = Sync.Unsafe.defer(unsafe.sumThenReset())
 
 end LongAdder
 
@@ -103,7 +103,7 @@ object LongAdder:
       *   The result of applying the function
       */
     inline def initWith[A, S](inline f: LongAdder => A < S)(using inline frame: Frame): A < (Sync & S) =
-        Sync.Unsafe(f(LongAdder(Unsafe.init())))
+        Sync.Unsafe.defer(f(LongAdder(Unsafe.init())))
 
     /** WARNING: Low-level API meant for integrations, libraries, and performance-sensitive code. See AllowUnsafe for more details. */
     opaque type Unsafe = j.LongAdder
@@ -158,7 +158,7 @@ final case class DoubleAdder private (unsafe: DoubleAdder.Unsafe):
       * @return
       *   Unit
       */
-    inline def add(v: Double)(using inline frame: Frame): Unit < Sync = Sync.Unsafe(unsafe.add(v))
+    inline def add(v: Double)(using inline frame: Frame): Unit < Sync = Sync.Unsafe.defer(unsafe.add(v))
 
     /** Returns the current sum.
       *
@@ -168,7 +168,7 @@ final case class DoubleAdder private (unsafe: DoubleAdder.Unsafe):
       * @return
       *   The current sum
       */
-    inline def get(using inline frame: Frame): Double < Sync = Sync.Unsafe(unsafe.get())
+    inline def get(using inline frame: Frame): Double < Sync = Sync.Unsafe.defer(unsafe.get())
 
     /** Resets the sum to zero.
       *
@@ -177,7 +177,7 @@ final case class DoubleAdder private (unsafe: DoubleAdder.Unsafe):
       * @return
       *   Unit
       */
-    inline def reset(using inline frame: Frame): Unit < Sync = Sync.Unsafe(unsafe.reset())
+    inline def reset(using inline frame: Frame): Unit < Sync = Sync.Unsafe.defer(unsafe.reset())
 
     /** Returns the current sum and resets it to zero.
       *
@@ -187,7 +187,7 @@ final case class DoubleAdder private (unsafe: DoubleAdder.Unsafe):
       * @return
       *   The sum before reset,
       */
-    inline def sumThenReset(using inline frame: Frame): Double < Sync = Sync.Unsafe(unsafe.sumThenReset())
+    inline def sumThenReset(using inline frame: Frame): Double < Sync = Sync.Unsafe.defer(unsafe.sumThenReset())
 
 end DoubleAdder
 
@@ -207,7 +207,7 @@ object DoubleAdder:
       *   The result of applying the function
       */
     inline def initWith[A, S](inline f: DoubleAdder => A < S)(using inline frame: Frame): A < (Sync & S) =
-        Sync.Unsafe(f(DoubleAdder(Unsafe.init())))
+        Sync.Unsafe.defer(f(DoubleAdder(Unsafe.init())))
 
     /** WARNING: Low-level API meant for integrations, libraries, and performance-sensitive code. See AllowUnsafe for more details. */
     opaque type Unsafe = j.DoubleAdder

kyo-core/shared/src/main/scala/kyo/AllowUnsafe.scala

@@ -11,7 +11,7 @@ Options (in order of preference):
    def myFunction(implicit allow: AllowUnsafe) = // unsafe code here
 
 2. Suspend the operation with Sync
-   Sync.Unsafe { // unsafe code here }
+   Sync.Unsafe.defer { // unsafe code here }
 
 3. Import implicit evidence (last resort)
    import AllowUnsafe.embrace.danger

kyo-core/shared/src/main/scala/kyo/Async.scala

@@ -168,7 +168,7 @@ object Async extends AsyncPlatformSpecific:
             isolate.capture { state =>
                 Fiber.initUnscoped(isolate.isolate(state, v)).map { task =>
                     Clock.use { clock =>
-                        Sync.Unsafe {
+                        Sync.Unsafe.defer {
                             val sleepFiber = clock.unsafe.sleep(after)
                             sleepFiber.onComplete(_ => discard(task.unsafe.interrupt(Result.Failure(Timeout(Present(after))))))
                             task.unsafe.onComplete(_ => discard(sleepFiber.interrupt()))
@@ -743,7 +743,7 @@ object Async extends AsyncPlatformSpecific:
       *   A nested computation that returns the memoized result
       */
     def memoize[A, S](v: A < S)(using Frame): A < (S & Async) < Sync =
-        Sync.Unsafe {
+        Sync.Unsafe.defer {
             val ref = AtomicRef.Unsafe.init(Maybe.empty[Promise.Unsafe[A, Any]])
             @tailrec def loop(): A < (S & Async) =
                 ref.get() match
@@ -752,14 +752,14 @@ object Async extends AsyncPlatformSpecific:
                         val promise = Promise.Unsafe.init[A, Any]()
                         if ref.compareAndSet(Absent, Present(promise)) then
                             Abort.run(v).map { r =>
-                                Sync.Unsafe {
+                                Sync.Unsafe.defer {
                                     if !r.isSuccess then
                                         ref.set(Absent)
                                     promise.completeDiscard(r.map(Kyo.lift))
                                     Abort.get(r)
                                 }
                             }.handle(Sync.ensure {
-                                Sync.Unsafe {
+                                Sync.Unsafe.defer {
                                     if !promise.done() then
                                         ref.set(Absent)
                                 }