Merge branch 'main' into fix-delayed-injectL-test

core-tests/src/test/scala/libretto/BasicTests.scala

@@ -2,16 +2,16 @@ package libretto
 
 import java.util.concurrent.{Executors, ScheduledExecutorService}
 import java.util.concurrent.atomic.AtomicInteger
-import libretto.Functor._
+import libretto.Functor.*
 import libretto.lambda.util.SourcePos
-import libretto.lambda.util.Monad.syntax._
+import libretto.lambda.util.Monad.syntax.*
 import libretto.scaletto.ScalettoLib
 import libretto.testing.{TestCase, TestExecutor, TestKit}
 import libretto.testing.scaletto.{ScalettoTestExecutor, ScalettoTestKit}
 import libretto.testing.scalatest.ScalatestSuite
 import libretto.util.Async
 import scala.concurrent.{Await, Promise}
-import scala.concurrent.duration._
+import scala.concurrent.duration.*
 
 class BasicTests extends ScalatestSuite[ScalettoTestKit] {
   private var scheduler: ScheduledExecutorService = _
@@ -38,13 +38,13 @@ class BasicTests extends ScalatestSuite[ScalettoTestKit] {
     )
 
   override def testCases(using kit: ScalettoTestKit): List[(String, TestCase[kit.type])] = {
-    import kit.{OutPort => _, _}
-    import dsl._
-    import dsl.$._
+    import kit.{OutPort => _, *}
+    import dsl.*
+    import dsl.$.*
     val coreLib = CoreLib(dsl)
     val scalettoLib = ScalettoLib(dsl: dsl.type, coreLib)
-    import coreLib._
-    import scalettoLib.{_, given}
+    import coreLib.{*, given}
+    import scalettoLib.{*, given}
     import kit.bridge.Execution
 
     def raceKeepWinner[A](

core-tests/src/test/scala/libretto/ClosureTests.scala

@@ -1,22 +1,22 @@
 package libretto
 
-import libretto.lambda.util.Monad.syntax._
+import libretto.lambda.util.Monad.syntax.*
 import libretto.scaletto.ScalettoLib
 import libretto.testing.TestCase
 import libretto.testing.scaletto.ScalettoTestKit
 import libretto.testing.scalatest.scaletto.ScalatestScalettoTestSuite
 
 class ClosureTests extends ScalatestScalettoTestSuite {
   override def testCases(using kit: ScalettoTestKit): List[(String, TestCase[kit.type])] = {
-    import kit.dsl._
-    import kit.dsl.$._
+    import kit.dsl.*
+    import kit.dsl.$.*
     import kit.{Outcome, expectVal}
     import kit.Outcome.expectNotThrows
 
     val coreLib = CoreLib(kit.dsl)
     val scalettoLib = ScalettoLib(kit.dsl, coreLib)
-    import coreLib._
-    import scalettoLib._
+    import coreLib.*
+    import scalettoLib.{*, given}
 
     List(
       "simplest closure" ->

core/src/main/scala/libretto/Bifunctor.scala

@@ -26,7 +26,7 @@ trait Bifunctor[->[_, _], F[_, _]] { self =>
         Bifunctor.this.lift[A, A, B1, B2](this.category.id[A], g)
     }
 
-  def inside[G[_]](implicit G: Functor[->, G]): Bifunctor[->, λ[(x, y) => G[F[x, y]]]] =
+  def inside[G[_]](using G: Functor[->, G]): Bifunctor[->, λ[(x, y) => G[F[x, y]]]] =
     new Bifunctor[->, λ[(x, y) => G[F[x, y]]]] {
       override val category =
         self.category

core/src/main/scala/libretto/Bridge.scala

@@ -16,7 +16,7 @@ trait CoreBridge {
 
 trait CoreExecution[DSL <: CoreDSL] {
   val dsl: DSL
-  import dsl._
+  import dsl.*
 
   type OutPort[A]
   val OutPort: OutPorts

core/src/main/scala/libretto/ClosedLib.scala

@@ -16,8 +16,8 @@ class ClosedLib[
   val dsl: DSL,
   val coreLib: CLib with CoreLib[dsl.type],
 ) { lib =>
-  import dsl._
-  import coreLib._
+  import dsl.*
+  import coreLib.*
 
   /** Function object (internal hom) is contravariant in the input type. */
   def input[C]: ContraFunctor[[x] =>> x =⚬ C] =
@@ -43,31 +43,31 @@ class ClosedLib[
         out(f)
     }
 
-  implicit class ClosedLinearFunctionOps[A, B](self: A -⚬ B) {
-    def curry[A1, A2](implicit ev: A =:= (A1 |*| A2)): A1 -⚬ (A2 =⚬ B) =
-      dsl.curry(ev.substituteCo[λ[x => x -⚬ B]](self))
+  extension [A, B](f: A -⚬ B) {
+    def curry[A1, A2](using ev: A =:= (A1 |*| A2)): A1 -⚬ (A2 =⚬ B) =
+      dsl.curry(ev.substituteCo[λ[x => x -⚬ B]](f))
 
-    def uncurry[B1, B2](implicit ev: B =:= (B1 =⚬ B2)): (A |*| B1) -⚬ B2 =
-      dsl.uncurry(ev.substituteCo(self))
+    def uncurry[B1, B2](using ev: B =:= (B1 =⚬ B2)): (A |*| B1) -⚬ B2 =
+      dsl.uncurry(ev.substituteCo(f))
   }
 
-  implicit class FocusedOnFunctionCo[F[_], A, B](f: FocusedCo[F, A =⚬ B]) {
+  extension [F[_], A, B](f: FocusedCo[F, A =⚬ B]) {
     def input: FocusedContra[λ[x => F[x =⚬ B]], A] =
       f.zoomContra(lib.input[B])
 
     def output: FocusedCo[λ[x => F[A =⚬ x]], B] =
       f.zoomCo(lib.output[A])
   }
 
-  implicit class FocusedOnFunctionContra[F[_], A, B](f: FocusedContra[F, A =⚬ B]) {
+  extension [F[_], A, B](f: FocusedContra[F, A =⚬ B]) {
     def input: FocusedCo[λ[x => F[x =⚬ B]], A] =
       f.zoomContra(lib.input[B])
 
     def output: FocusedContra[λ[x => F[A =⚬ x]], B] =
       f.zoomCo(lib.output[A])
   }
 
-  def zapPremises[A, Ā, B, C](implicit ev: Dual[A, Ā]): ((A =⚬ B) |*| (Ā =⚬ C)) -⚬ (B |*| C) = {
+  def zapPremises[A, Ā, B, C](using ev: Dual[A, Ā]): ((A =⚬ B) |*| (Ā =⚬ C)) -⚬ (B |*| C) = {
     id                              [  (A =⚬ B) |*| (Ā =⚬ C)                ]
       .introSnd(ev.lInvert)      .to[ ((A =⚬ B) |*| (Ā =⚬ C)) |*| (Ā |*| A) ]
       .>.snd(swap)               .to[ ((A =⚬ B) |*| (Ā =⚬ C)) |*| (A |*| Ā) ]
@@ -78,7 +78,7 @@ class ClosedLib[
   /** Given `A` and `B` concurrently (`A |*| B`), we can suggest that `A` be consumed before `B`
     * by turning it into `Ā =⚬ B`, where `Ā` is the dual of `A`.
     */
-  def unveilSequentially[A, Ā, B](implicit ev: Dual[A, Ā]): (A |*| B) -⚬ (Ā =⚬ B) =
+  def unveilSequentially[A, Ā, B](using ev: Dual[A, Ā]): (A |*| B) -⚬ (Ā =⚬ B) =
     id[(A |*| B) |*| Ā]           .to[ (A |*|  B) |*| Ā  ]
       .assocLR                    .to[  A |*| (B  |*| Ā) ]
       .>.snd(swap)                .to[  A |*| (Ā  |*| B) ]