use initWith where possible

getkyo · Jan 20, 2025 · fa19dd5 · fa19dd5
1 parent 2f07f80
commit fa19dd5
Show file tree

Hide file tree

Showing 8 changed files with 11 additions and 11 deletions.
diff --git a/kyo-cache/shared/src/main/scala/kyo/Cache.scala b/kyo-cache/shared/src/main/scala/kyo/Cache.scala
@@ -33,7 +33,7 @@ class Cache(private[kyo] val store: Store):
         f: A => B < S
     )(using Frame): A => B < (Async & S) =
         (v: A) =>
-            Promise.init[Throwable, B].map { p =>
+            Promise.initWith[Throwable, B] { p =>
                 val key = (this, v)
                 IO[B, Async & S] {
                     val p2 = store.get(key, _ => p.asInstanceOf[Promise[Nothing, Any]])

diff --git a/kyo-core/shared/src/main/scala/kyo/Hub.scala b/kyo-core/shared/src/main/scala/kyo/Hub.scala
@@ -115,7 +115,7 @@ class Hub[A] private[kyo] (
         closed.map {
             case true => fail
             case false =>
-                Channel.init[A](bufferSize).map { child =>
+                Channel.initWith[A](bufferSize) { child =>
                     IO {
                         discard(listeners.add(child))
                         closed.map {
@@ -165,7 +165,7 @@ object Hub:
       *   The result of applying the function
       */
     def initWith[A](capacity: Int)[B, S](f: Hub[A] => B < S)(using Frame): B < (S & IO) =
-        Channel.init[A](capacity).map { ch =>
+        Channel.initWith[A](capacity) { ch =>
             IO {
                 val listeners = new CopyOnWriteArraySet[Channel[A]]
                 Async.run {

diff --git a/kyo-core/shared/src/main/scala/kyo/Resource.scala b/kyo-core/shared/src/main/scala/kyo/Resource.scala
@@ -99,8 +99,8 @@ object Resource:
       *   The result of the effect wrapped in Async and S effects.
       */
     def run[A, S](closeParallelism: Int)(v: A < (Resource & S))(using frame: Frame): A < (Async & S) =
-        Queue.Unbounded.init[Unit < (Async & Abort[Throwable])](Access.MultiProducerSingleConsumer).map { q =>
-            Promise.init[Nothing, Unit].map { p =>
+        Queue.Unbounded.initWith[Unit < (Async & Abort[Throwable])](Access.MultiProducerSingleConsumer) { q =>
+            Promise.initWith[Nothing, Unit] { p =>
                 val finalizer = Finalizer(frame, q)
                 def close: Unit < IO =
                     q.close.map {

diff --git a/kyo-stm/shared/src/main/scala/kyo/TTable.scala b/kyo-stm/shared/src/main/scala/kyo/TTable.scala
@@ -294,7 +294,7 @@ object TTable:
                 table <- TTable.init[Fields]
                 indexes <-
                     Kyo.foreach(indexFields.toSeq) { field =>
-                        TMap.init[Any, Set[Int]].map(field -> _)
+                        TMap.initWith[Any, Set[Int]](field -> _)
                     }
             yield new Indexed(table, indexes.toMap)(using fields)
     end Indexed

diff --git a/kyo-sttp/jvm/src/main/scala/sttp/client3/HttpClientKyoBackend.scala b/kyo-sttp/jvm/src/main/scala/sttp/client3/HttpClientKyoBackend.scala
@@ -57,7 +57,7 @@ class HttpClientKyoBackend private (
             ) = pipe
 
     override protected def createSimpleQueue[A] =
-        Channel.init[A](Int.MaxValue).map(new KyoSimpleQueue[A](_))
+        Channel.initWith[A](Int.MaxValue)(new KyoSimpleQueue[A](_))
 
     override protected def createSequencer =
         Meter.initMutex.map(new KyoSequencer(_))

diff --git a/kyo-sttp/shared/src/main/scala/kyo/internal/KyoSttpMonad.scala b/kyo-sttp/shared/src/main/scala/kyo/internal/KyoSttpMonad.scala
@@ -29,7 +29,7 @@ class KyoSttpMonad extends MonadAsyncError[M]:
         handleWrappedError(rt)(h)
 
     def ensure[A](f: M[A], e: => M[Unit]) =
-        Promise.init[Nothing, Unit].map { p =>
+        Promise.initWith[Nothing, Unit] { p =>
             def run =
                 Async.run(e).map(p.become).unit
             IO.ensure(run)(f).map(r => p.get.andThen(r))

diff --git a/kyo-tapir/shared/src/main/scala/kyo/server/internal/KyoUtil.scala b/kyo-tapir/shared/src/main/scala/kyo/server/internal/KyoUtil.scala
@@ -6,7 +6,7 @@ import kyo.*
 
 object KyoUtil:
     def nettyChannelFutureToScala(nettyFuture: ChannelFuture)(using Frame): Channel < Async =
-        Promise.init[Nothing, Channel].map { p =>
+        Promise.initWith[Nothing, Channel] { p =>
             p.onComplete(_ => IO(nettyFuture.cancel(true)).unit).andThen {
                 nettyFuture.addListener((future: ChannelFuture) =>
                     discard {
@@ -20,7 +20,7 @@ object KyoUtil:
         }
 
     def nettyFutureToScala[A](f: io.netty.util.concurrent.Future[A])(using Frame): A < Async =
-        Promise.init[Nothing, A].map { p =>
+        Promise.initWith[Nothing, A] { p =>
             p.onComplete(_ => IO(f.cancel(true)).unit).andThen {
                 f.addListener((future: io.netty.util.concurrent.Future[A]) =>
                     discard {

diff --git a/kyo-tapir/shared/src/main/scala/kyo/server/internal/NettyKyoRequestBody.scala b/kyo-tapir/shared/src/main/scala/kyo/server/internal/NettyKyoRequestBody.scala
@@ -23,7 +23,7 @@ private[netty] class NettyKyoRequestBody(val createFile: ServerRequest => KyoStt
         contentLength: Option[Long],
         maxBytes: Option[Long]
     ): KyoSttpMonad.M[Array[Byte]] =
-        Promise.init[Nothing, Array[Byte]].map { p =>
+        Promise.initWith[Nothing, Array[Byte]] { p =>
             val fut = SimpleSubscriber.processAll(publisher, contentLength, maxBytes)
             fut.onComplete { r =>
                 import AllowUnsafe.embrace.danger