Abstract over exit in Fibers

tofu-tf · Jul 1, 2021 · 5e197fe · 5e197fe
1 parent 4590213
commit 5e197fe
Show file tree

Hide file tree

Showing 5 changed files with 23 additions and 17 deletions.
diff --git a/core/src/main/scala/tofu/package.scala b/core/src/main/scala/tofu/package.scala
@@ -2,6 +2,7 @@ import cats.effect.Bracket
 import cats.effect.Fiber
 import cats.data.Ior
 import tofu.kernel.KernelTypes
+import cats.Id
 
 package object tofu extends KernelTypes {
 
@@ -17,5 +18,5 @@ package object tofu extends KernelTypes {
   type Calculates[F[_]] = Scoped[Scoped.Calculation, F]
   type CalcExec[F[_]]   = ScopedExecute[Scoped.Calculation, F]
 
-  type Start[F[_]] = Fibers[F, Fiber[F, *]]
+  type Start[F[_]] = Fibers[F, Id, Fiber[F, *]]
 }
diff --git a/kernel/src/main/scala/tofu/Fire.scala b/kernel/src/main/scala/tofu/Fire.scala
@@ -1,17 +1,17 @@
 package tofu
 
 import scala.util.Either
-import tofu.internal.{EffectComp, Effect2Comp}
+import tofu.internal.{EffectComp, Effect3Comp}
 import tofu.internal.carriers.FibersCarrier
 
 trait Fire[F[_]] {
   def fireAndForget[A](fa: F[A]): F[Unit]
 }
 
 object Fire extends EffectComp[Fire] {
-  final implicit def byCarrier[F[_], Fib[_]](implicit
-      carrier: FibersCarrier.Aux[F, Fib]
-  ): Fibers[F, Fib] = carrier.content
+  final implicit def byCarrier[F[_], Ex[_], Fib[_]](implicit
+      carrier: FibersCarrier.Aux[F, Ex, Fib]
+  ): Fibers[F, Ex, Fib] = carrier.content
 }
 
 trait Race[F[_]] extends Fire[F] {
@@ -23,9 +23,9 @@ object Race extends EffectComp[Race] {
   def never[F[_], A](implicit race: Race[F]): F[A] = race.never
 }
 
-trait Fibers[F[_], Fib[_]] extends Race[F] {
+trait Fibers[F[_], Exit[_], Fib[_]] extends Race[F] {
   def start[A](fa: F[A]): F[Fib[A]]
   def racePair[A, B](fa: F[A], fb: F[B]): F[Either[(A, Fib[B]), (Fib[A], B)]]
 }
 
-object Fibers extends Effect2Comp[Fibers]
+object Fibers extends Effect3Comp[Fibers]
diff --git a/kernel/src/main/scala/tofu/internal/DataEffectComp.scala b/kernel/src/main/scala/tofu/internal/DataEffectComp.scala
@@ -12,6 +12,10 @@ trait Effect2Comp[TC[f[_], g[_]]] {
   @inline final def apply[F[_], G[_]](implicit instance: TC[F, G]): TC[F, G] = instance
 }
 
+trait Effect3Comp[TC[f[_], g[_], h[_]]] {
+  @inline final def apply[F[_], G[_], H[_]](implicit instance: TC[F, G, H]): TC[F, G, H] = instance
+}
+
 trait DataComp[TC[_]] {
   @inline final def apply[A](implicit instance: TC[A]): TC[A] = instance
 }
diff --git a/kernel/src/main/scala/tofu/internal/carriers/FibersCarrier.scala b/kernel/src/main/scala/tofu/internal/carriers/FibersCarrier.scala
@@ -4,17 +4,18 @@ import tofu.internal.WBInterop
 
 abstract class FibersCarrier[F[_]] {
   type Fib[_]
-
-  val content: Fibers[F, Fib]
+  type Exit[_]
+  val content: Fibers[F, Exit, Fib]
 }
 
 object FibersCarrier {
-  type Aux[F[_], Fb[_]] = FibersCarrier[F] { type Fib[a] = Fb[a] }
-  def apply[F[_], Fb[_]](fin: Fibers[F, Fb]) = new FibersCarrier[F] {
-    type Fib[a] = Fb[a]
+  type Aux[F[_], Ex[_], Fb[_]] = FibersCarrier[F] { type Exit[a] = Ex[a]; type Fib[a] = Fb[a]; }
+  def apply[F[_], Ex[_], Fb[_]](fin: Fibers[F, Ex, Fb]) = new FibersCarrier[F] {
+    type Fib[a]  = Fb[a]
+    type Exit[a] = Ex[a]
     val content = fin
   }
 
-  final implicit def startFromConcurrent[F[_], Exit[_]]: Aux[F, Exit] =
+  final implicit def startFromConcurrent[F[_], Exit[_], Fiber[_]]: Aux[F, Exit, Fiber] =
     macro WBInterop.delegate0[F, { val `tofu.interop.CE2Kernel.startFromConcurrent`: Unit }]
 }
diff --git a/kernelCE2Interop/src/main/scala/tofu/interop/CE2Kernel.scala b/kernelCE2Interop/src/main/scala/tofu/interop/CE2Kernel.scala
@@ -7,7 +7,7 @@ import tofu.Delay
 import cats.effect.Effect
 import cats.effect.IO
 import tofu.syntax.monadic._
-import cats.~>
+import cats.{~>, Id}
 import cats.effect.Concurrent
 import cats.effect.Timer
 import cats.effect.Fiber
@@ -60,9 +60,9 @@ object CE2Kernel {
   final implicit def startFromConcurrent[F[_]](implicit
       F: Concurrent[F],
       @unused _nonTofu: NonTofu[F]
-  ): FibersCarrier.Aux[F, Fiber[F, *]] =
-    FibersCarrier[F, Fiber[F, *]](
-      new Fibers[F, Fiber[F, *]] {
+  ): FibersCarrier.Aux[F, Id, Fiber[F, *]] =
+    FibersCarrier[F, Id, Fiber[F, *]](
+      new Fibers[F, Id, Fiber[F, *]] {
         def start[A](fa: F[A]): F[Fiber[F, A]]                                                = F.start(fa)
         def fireAndForget[A](fa: F[A]): F[Unit]                                               = F.void(start(fa))
         def racePair[A, B](fa: F[A], fb: F[B]): F[Either[(A, Fiber[F, B]), (Fiber[F, A], B)]] = F.racePair(fa, fb)