adopted do dotty-cps-async-0.9.6

rssh · rssh · commit 107ffea0083b · 2022-01-24T17:50:56.000+02:00
diff --git a/README.md b/README.md
@@ -4,10 +4,16 @@
 
 ### Dependences:    
  
-For scala 3:
+For scala 3.1.1+:
+
+    libraryDependencies += "com.github.rssh" %% "scala-gopher" % "3.0.0"
+
+For scala 3 and 3.1.0:
 
     libraryDependencies += "com.github.rssh" %% "scala-gopher" % "2.1.0"
 
+Note, that 3.0.0 have no new functionality agains 2.1.0 but need to be a next major release because of binary incompability caused by difference between dotty-cps-async-0.9.5 and 0.9.6.
+
 For scala2: 
 
     libraryDependencies += "com.github.rssh" %% "scala-gopher" % "0.99.15"
diff --git a/build.sbt b/build.sbt
@@ -1,16 +1,16 @@
 //val dottyVersion = "3.0.0-RC2-bin-SNAPSHOT"
-val dottyVersion = "3.1.0"
+val dottyVersion = "3.1.1"
 //val dottyVersion = dottyLatestNightlyBuild.get
 
-ThisBuild/version := "2.1.2-SNAPSHOT"
+ThisBuild/version := "3.0.0"
 ThisBuild/versionScheme := Some("semver-spec")
 
 val sharedSettings = Seq(
     organization := "com.github.rssh",
     scalaVersion := dottyVersion,
     name := "scala-gopher",
     resolvers += "Local Ivy Repository" at "file://"+Path.userHome.absolutePath+"/.ivy2/local",
-    libraryDependencies += "com.github.rssh" %%% "dotty-cps-async" % "0.9.4",
+    libraryDependencies += "com.github.rssh" %%% "dotty-cps-async" % "0.9.6",
     libraryDependencies += "org.scalameta" %%% "munit" % "0.7.29" % Test,
 )
 
@@ -45,7 +45,7 @@ lazy val gopher = crossProject(JSPlatform, JVMPlatform)
         Compile / doc / scalacOptions := Seq("-groups",
                 "-source-links:shared=github://rssh/scala-gopher/master#shared",
                 "-source-links:jvm=github://rssh/scala-gopher/master#jvm"),
-        mimaPreviousArtifacts := Set( "com.github.rssh" %% "scala-gopher" % "2.1.0")
+        mimaPreviousArtifacts := Set()  //Set( "com.github.rssh" %% "scala-gopher" % "2.1.0")
     ).jsSettings(
         libraryDependencies += ("org.scala-js" %%% "scalajs-java-logging" % "1.0.0").cross(CrossVersion.for3Use2_13),
         // TODO: switch to ModuleES ?
diff --git a/project/plugins.sbt b/project/plugins.sbt
@@ -2,5 +2,5 @@ addSbtPlugin("com.jsuereth" % "sbt-pgp" % "2.0.2")
 addSbtPlugin("com.typesafe.sbt" % "sbt-site" % "1.4.1")
 addSbtPlugin("com.typesafe.sbt" % "sbt-ghpages" % "0.6.3")
 addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject"      % "1.0.0")
-addSbtPlugin("org.scala-js" % "sbt-scalajs"      % "1.7.1")
+addSbtPlugin("org.scala-js" % "sbt-scalajs"      % "1.8.0")
 addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "1.0.1")
diff --git a/shared/src/main/scala/gopher/Gopher.scala b/shared/src/main/scala/gopher/Gopher.scala
@@ -83,7 +83,7 @@ trait Gopher[F[_]:CpsSchedulingMonad]:
      }
 
 end Gopher
-  
+
 
 /**
 * Create Read/Write channel. 
diff --git a/shared/src/main/scala/gopher/ReadChannel.scala b/shared/src/main/scala/gopher/ReadChannel.scala
@@ -52,12 +52,12 @@ trait ReadChannel[F[_], A]:
     * Can be used only inside async block.
     * If stream is closed and no values to read left in the stream - throws StreamClosedException
     **/   
-   transparent inline def read(): A = await(aread())(using rAsyncMonad)
+   transparent inline def read()(using CpsMonadContext[F]): A = await(aread())(using rAsyncMonad)
 
    /**
    * Synonim for read.
    */
-   transparent inline def ? : A = await(aread())(using rAsyncMonad)
+   transparent inline def ?(using CpsMonadContext[F]) : A = await(aread())(using rAsyncMonad)
 
   /**
    * return F which contains sequence from first `n` elements.
@@ -83,7 +83,7 @@ trait ReadChannel[F[_], A]:
    * take first `n` elements.
    * should be called inside async block. 
    **/   
-   transparent inline def take(n: Int): IndexedSeq[A] =
+   transparent inline def take(n: Int)(using CpsMonadContext[F]): IndexedSeq[A] =
       await(atake(n))(using rAsyncMonad)
 
    /**
@@ -107,7 +107,7 @@ trait ReadChannel[F[_], A]:
     *
     * should be called inside async block.
     **/   
-   transparent inline def optRead(): Option[A] = await(aOptRead())(using rAsyncMonad)
+   transparent inline def optRead()(using CpsMonadContext[F]): Option[A] = await(aOptRead())(using rAsyncMonad)
 
    def foreach_async(f: A=>F[Unit]): F[Unit] =
       given CpsAsyncMonad[F] = asyncMonad
@@ -130,7 +130,7 @@ trait ReadChannel[F[_], A]:
    * run code each time when new object is arriced.
    * until end of stream is not reached
    **/  
-   transparent inline def foreach(inline f: A=>Unit): Unit = 
+   transparent inline def foreach(inline f: A=>Unit)(using CpsMonadContext[F]): Unit = 
       await(aforeach(f))(using rAsyncMonad)
 
 
@@ -170,8 +170,8 @@ trait ReadChannel[F[_], A]:
          s
       }
    
-   transparent inline def fold[S](inline s0:S)(inline f: (S,A) => S ): S =
-      await[F,S](afold(s0)(f))(using rAsyncMonad)   
+   transparent inline def fold[S](inline s0:S)(inline f: (S,A) => S )(using mc:CpsMonadContext[F]): S =
+      await[F,S,F](afold(s0)(f))(using rAsyncMonad, mc)   
    
    def zip[B](x: ReadChannel[F,B]): ReadChannel[F,(A,B)] = 
       given CpsSchedulingMonad[F] = asyncMonad
@@ -317,14 +317,18 @@ object ReadChannel:
       }   
 
 
-
+   
    import cps.stream._ 
 
-   given emitAbsorber[F[_]: CpsSchedulingMonad,T](using gopherApi: Gopher[F]): BaseUnfoldCpsAsyncEmitAbsorber[ReadChannel[F,T],F,T](
-                                                using gopherApi.asyncMonad, gopherApi.taskExecutionContext) with
+   given emitAbsorber[F[_], C<:CpsMonadContext[F], T](using auxMonad: CpsSchedulingMonad[F]{ type Context = C },  gopherApi: Gopher[F]): BaseUnfoldCpsAsyncEmitAbsorber[ReadChannel[F,T],F,C,T](
+                                                using gopherApi.taskExecutionContext, auxMonad) with
          
       override type Element = T
 
+      def asSync(fs: F[ReadChannel[F,T]]): ReadChannel[F,T] =
+         DelayedReadChannel(fs)
+         
+
       def unfold[S](s0:S)(f: S => F[Option[(T,S)]]): ReadChannel[F,T] = 
          val r: ReadChannel[F,T] = unfoldAsync(s0)(f)
          r
diff --git a/shared/src/main/scala/gopher/Select.scala b/shared/src/main/scala/gopher/Select.scala
@@ -26,9 +26,9 @@ class Select[F[_]](api: Gopher[F]):
    *}
    *```
    */
-  transparent inline def apply[A](inline pf: PartialFunction[Any,A]): A =
+  transparent inline def apply[A](inline pf: PartialFunction[Any,A])(using mc:CpsMonadContext[F]): A =
     ${  
-      SelectMacro.onceImpl[F,A]('pf, 'api )  
+      SelectMacro.onceImpl[F,A]('pf, 'api, 'mc )  
      }    
 
   /**
@@ -68,7 +68,8 @@ class Select[F[_]](api: Gopher[F]):
   }
 
   transparent inline def afold[S](s0:S)(inline step: S => S | SelectFold.Done[S]) : F[S] =
-    async[F](using api.asyncMonad).apply{
+    given CpsAsyncMonad[F] = api.asyncMonad
+    async[F]{ 
       fold(s0)(step)
     }
 
diff --git a/shared/src/main/scala/gopher/SelectForever.scala b/shared/src/main/scala/gopher/SelectForever.scala
@@ -12,9 +12,9 @@ import scala.concurrent.duration._
 class SelectForever[F[_]](api: Gopher[F]) extends SelectGroupBuilder[F,Unit, Unit](api):
 
 
-  transparent inline def apply(inline pf: PartialFunction[Any,Unit]): Unit =
+  transparent inline def apply(inline pf: PartialFunction[Any,Unit])(using mc:CpsMonadContext[F]): Unit =
     ${  
-      SelectMacro.foreverImpl('pf,'api)
+      SelectMacro.foreverImpl('pf,'api, 'mc)
     }
 
 
diff --git a/shared/src/main/scala/gopher/SelectGroup.scala b/shared/src/main/scala/gopher/SelectGroup.scala
@@ -73,14 +73,14 @@ class SelectGroup[F[_], S](api: Gopher[F])  extends SelectListeners[F,S,S]:
     def runAsync():F[S] =
        retval
 
-    transparent inline def apply(inline pf: PartialFunction[Any,S]): S =
+    transparent inline def apply(inline pf: PartialFunction[Any,S])(using mc: CpsMonadContext[F]): S =
     ${  
-        SelectMacro.onceImpl[F,S]('pf, 'api )  
+        SelectMacro.onceImpl[F,S]('pf, 'api, 'mc )  
     }    
   
-    transparent inline def select(inline pf: PartialFunction[Any,S]): S =
+    transparent inline def select(inline pf: PartialFunction[Any,S])(using mc: CpsMonadContext[F]): S =
     ${  
-        SelectMacro.onceImpl[F,S]('pf, 'api )  
+        SelectMacro.onceImpl[F,S]('pf, 'api, 'mc )  
     }
 
     /**
diff --git a/shared/src/main/scala/gopher/SelectListeners.scala b/shared/src/main/scala/gopher/SelectListeners.scala
@@ -16,7 +16,7 @@ trait SelectListeners[F[_],S, R]:
 
   def  runAsync():F[R]
  
-  transparent inline def run(): R = await(runAsync())(using asyncMonad)
+  transparent inline def run()(using CpsMonadContext[F]): R = await(runAsync())(using asyncMonad)
 
 
 
diff --git a/shared/src/main/scala/gopher/SelectLoop.scala b/shared/src/main/scala/gopher/SelectLoop.scala
@@ -11,9 +11,9 @@ import java.util.logging.{Level => LogLevel}
 class SelectLoop[F[_]](api: Gopher[F]) extends SelectGroupBuilder[F,Boolean, Unit](api):
 
 
-  transparent inline def apply(inline pf: PartialFunction[Any,Boolean]): Unit =
+  transparent inline def apply(inline pf: PartialFunction[Any,Boolean])(using mc: CpsMonadContext[F]): Unit =
     ${  
-      SelectMacro.loopImpl[F]('pf,  'api )  
+      SelectMacro.loopImpl[F]('pf,  'api, 'mc )  
     }
       
   def runAsync(): F[Unit] = 
diff --git a/shared/src/main/scala/gopher/SelectMacro.scala b/shared/src/main/scala/gopher/SelectMacro.scala
@@ -51,10 +51,12 @@ object SelectMacro:
   def buildSelectListenerRun[F[_]:Type, S:Type, R:Type, L <: SelectListeners[F,S,R]:Type](
            constructor: Expr[L], 
            caseDefs: List[SelectorCaseExpr[F,S,R]], 
-           api:Expr[Gopher[F]])(using Quotes): Expr[R] =
+           api:Expr[Gopher[F]],
+           monadContext: Expr[CpsMonadContext[F]],
+           )(using Quotes): Expr[R] =
             val g = selectListenerBuilder(constructor, caseDefs)
             //  dotty bug if g.run
-            val r = '{ await($g.runAsync())(using ${api}.asyncMonad) } 
+            val r = '{ await($g.runAsync())(using ${api}.asyncMonad, $monadContext) } 
             r.asExprOf[R]
 
   def buildSelectListenerRunAsync[F[_]:Type, S:Type, R:Type, L <: SelectListeners[F,S,R]:Type](
@@ -68,31 +70,31 @@ object SelectMacro:
    
    
 
-  def onceImpl[F[_]:Type, A:Type](pf: Expr[PartialFunction[Any,A]], api: Expr[Gopher[F]])(using Quotes): Expr[A] =
+  def onceImpl[F[_]:Type, A:Type](pf: Expr[PartialFunction[Any,A]], api: Expr[Gopher[F]], monadContext: Expr[CpsMonadContext[F]])(using Quotes): Expr[A] =
        def builder(caseDefs: List[SelectorCaseExpr[F,A,A]]):Expr[A] = {
           val s0 = '{
              new SelectGroup[F,A]($api)
           }
-          buildSelectListenerRun(s0, caseDefs, api)
+          buildSelectListenerRun(s0, caseDefs, api, monadContext)
        }
        runImpl(builder, pf)
 
-  def loopImpl[F[_]:Type](pf: Expr[PartialFunction[Any,Boolean]], api: Expr[Gopher[F]])(using Quotes): Expr[Unit] =
+  def loopImpl[F[_]:Type](pf: Expr[PartialFunction[Any,Boolean]], api: Expr[Gopher[F]], monadContext: Expr[CpsMonadContext[F]])(using Quotes): Expr[Unit] =
       def builder(caseDefs: List[SelectorCaseExpr[F,Boolean,Unit]]):Expr[Unit] = {
           val s0 = '{
               new SelectLoop[F]($api)
           }
-          buildSelectListenerRun(s0, caseDefs, api)
+          buildSelectListenerRun(s0, caseDefs, api, monadContext)
       }
       runImpl( builder, pf)
       
 
-  def foreverImpl[F[_]:Type](pf: Expr[PartialFunction[Any,Unit]], api:Expr[Gopher[F]])(using Quotes): Expr[Unit] =
+  def foreverImpl[F[_]:Type](pf: Expr[PartialFunction[Any,Unit]], api:Expr[Gopher[F]], monadContext: Expr[CpsMonadContext[F]])(using Quotes): Expr[Unit] =
       def builder(caseDefs: List[SelectorCaseExpr[F,Unit,Unit]]):Expr[Unit] = {
           val s0 = '{
               new SelectForever[F]($api)
           }
-          buildSelectListenerRun(s0, caseDefs, api)
+          buildSelectListenerRun(s0, caseDefs, api, monadContext)
       }
       runImpl(builder, pf)
 
diff --git a/shared/src/main/scala/gopher/Time.scala b/shared/src/main/scala/gopher/Time.scala
@@ -60,7 +60,7 @@ abstract class Time[F[_]](gopherAPI: Gopher[F]) {
     /**
      * synonim for `await(asleep(duration))`.  Should be used inside async block.
      **/
-    transparent inline def sleep(duration: FiniteDuration): FiniteDuration = 
+    transparent inline def sleep(duration: FiniteDuration)(using CpsMonadContext[F]): FiniteDuration = 
         given CpsSchedulingMonad[F] = gopherAPI.asyncMonad
         await(asleep(duration))
 
@@ -156,7 +156,7 @@ object Time:
     def asleep[F[_]](duration: FiniteDuration)(using Gopher[F]): F[FiniteDuration] =
         summon[Gopher[F]].time.asleep(duration)
 
-    transparent inline def sleep[F[_]](duration: FiniteDuration)(using Gopher[F]): FiniteDuration = 
+    transparent inline def sleep[F[_]](duration: FiniteDuration)(using Gopher[F], CpsMonadContext[F]): FiniteDuration = 
         summon[Gopher[F]].time.sleep(duration)    
     
 
diff --git a/shared/src/main/scala/gopher/WriteChannel.scala b/shared/src/main/scala/gopher/WriteChannel.scala
@@ -23,13 +23,13 @@ trait WriteChannel[F[_], A]:
    //   inline def apply(a:A): Unit = await(awrite(a))(using asyncMonad) 
    //   inline def unapply(a:A): Some[A] = ???
 
-   transparent inline def write(inline a:A): Unit = await(awrite(a))(using asyncMonad)
+   transparent inline def write(inline a:A)(using CpsMonadContext[F]): Unit = await(awrite(a))(using asyncMonad)
 
    @targetName("write1")
-   transparent inline def <~ (inline a:A): Unit = await(awrite(a))(using asyncMonad) 
+   transparent inline def <~ (inline a:A)(using CpsMonadContext[F]): Unit = await(awrite(a))(using asyncMonad) 
 
    @targetName("write2")
-   transparent inline def ! (inline a:A): Unit = await(awrite(a))(using asyncMonad) 
+   transparent inline def ! (inline a:A)(using CpsMonadContext[F]): Unit = await(awrite(a))(using asyncMonad) 
 
 
    //def Write(x:A):WritePattern = new WritePattern(x)
@@ -51,8 +51,8 @@ trait WriteChannel[F[_], A]:
         }
       }
 
-   transparent inline def writeAll(inline collection: IterableOnce[A]): Unit = 
-      await(awriteAll(collection))(using asyncMonad)
+   transparent inline def writeAll(inline collection: IterableOnce[A])(using mc: CpsMonadContext[F]): Unit = 
+      await(awriteAll(collection))(using asyncMonad, mc)
 
 
    def withWriteExpiration(ttl: FiniteDuration, throwTimeouts: Boolean)(using gopherApi: Gopher[F]): WriteChannelWithExpiration[F,A] =
diff --git a/shared/src/main/scala/gopher/monads/ReadChannelCpsMonad.scala b/shared/src/main/scala/gopher/monads/ReadChannelCpsMonad.scala
@@ -6,7 +6,8 @@ import cps._
 import gopher.impl._
 
 
-given ReadChannelCpsMonad[F[_]](using Gopher[F]): CpsMonad[ [A] =>> ReadChannel[F,A]] with
+given ReadChannelCpsMonad[F[_]](using Gopher[F]): CpsMonad[[A] =>> ReadChannel[F,A]] with CpsMonadInstanceContext[[A] =>> ReadChannel[F,A]] with
+
 
   def pure[T](t:T): ReadChannel[F,T] = 
      ReadChannel.fromValues[F,T](t)
diff --git a/shared/src/main/scala/gopher/monads/ReadTryChannelCpsMonad.scala b/shared/src/main/scala/gopher/monads/ReadTryChannelCpsMonad.scala
@@ -7,7 +7,7 @@ import cps._
 import gopher.impl._
 
 
-given ReadTryChannelCpsMonad[F[_]](using Gopher[F]): CpsAsyncMonad[ [A] =>> ReadChannel[F,Try[A]] ] with
+given ReadTryChannelCpsMonad[F[_]](using Gopher[F]): CpsAsyncMonad[[A] =>> ReadChannel[F,Try[A]]] with CpsMonadInstanceContext[[A] =>> ReadChannel[F,Try[A]]] with
 
   type FW[T] = [A] =>> ReadChannel[F,Try[A]]
 
diff --git a/shared/src/test/scala/examples/SieveSuite.scala b/shared/src/test/scala/examples/SieveSuite.scala
@@ -48,6 +48,7 @@ object Sieve
 
   def filter1(in:Channel[Future,Int,Int]):ReadChannel[Future,Int] =
   {
+   //implicit val printCode = cps.macros.flags.PrintCode 
    val q = makeChannel[Int]()
    val filtered = makeChannel[Int]()
    select.afold(in){ ch => 

Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ trait Gopher[F[_]:CpsSchedulingMonad]:`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`end Gopher`
`86`		`-`
	`86`	`+`
`87`	`87`
`88`	`88`	`/**`
`89`	`89`	`* Create Read/Write channel.`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,9 @@ class Select[F[_]](api: Gopher[F]):`
`26`	`26`	`*}`
`27`	`27`	*```
`28`	`28`	`*/`
`29`		`- transparent inline def apply[A](inline pf: PartialFunction[Any,A]): A =`
	`29`	`+ transparent inline def apply[A](inline pf: PartialFunction[Any,A])(using mc:CpsMonadContext[F]): A =`
`30`	`30`	`${`
`31`		`- SelectMacro.onceImpl[F,A]('pf, 'api )`
	`31`	`+ SelectMacro.onceImpl[F,A]('pf, 'api, 'mc )`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`/**`
`@@ -68,7 +68,8 @@ class Select[F[_]](api: Gopher[F]):`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`transparent inline def afold[S](s0:S)(inline step: S => S \| SelectFold.Done[S]) : F[S] =`
`71`		`- async[F](using api.asyncMonad).apply{`
	`71`	`+ given CpsAsyncMonad[F] = api.asyncMonad`
	`72`	`+ async[F]{`
`72`	`73`	`fold(s0)(step)`
`73`	`74`	`}`
`74`	`75`
Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,9 @@ import scala.concurrent.duration._`
`12`	`12`	`class SelectForever[F[_]](api: Gopher[F]) extends SelectGroupBuilder[F,Unit, Unit](api):`
`13`	`13`
`14`	`14`
`15`		`- transparent inline def apply(inline pf: PartialFunction[Any,Unit]): Unit =`
	`15`	`+ transparent inline def apply(inline pf: PartialFunction[Any,Unit])(using mc:CpsMonadContext[F]): Unit =`
`16`	`16`	`${`
`17`		`- SelectMacro.foreverImpl('pf,'api)`
	`17`	`+ SelectMacro.foreverImpl('pf,'api, 'mc)`
`18`	`18`	`}`
`19`	`19`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ trait SelectListeners[F[_],S, R]:`
`16`	`16`
`17`	`17`	`def runAsync():F[R]`
`18`	`18`
`19`		`- transparent inline def run(): R = await(runAsync())(using asyncMonad)`
	`19`	`+ transparent inline def run()(using CpsMonadContext[F]): R = await(runAsync())(using asyncMonad)`
`20`	`20`
`21`	`21`
`22`	`22`
Original file line number	Diff line number	Diff line change
`@@ -11,9 +11,9 @@ import java.util.logging.{Level => LogLevel}`
`11`	`11`	`class SelectLoop[F[_]](api: Gopher[F]) extends SelectGroupBuilder[F,Boolean, Unit](api):`
`12`	`12`
`13`	`13`
`14`		`- transparent inline def apply(inline pf: PartialFunction[Any,Boolean]): Unit =`
	`14`	`+ transparent inline def apply(inline pf: PartialFunction[Any,Boolean])(using mc: CpsMonadContext[F]): Unit =`
`15`	`15`	`${`
`16`		`- SelectMacro.loopImpl[F]('pf, 'api )`
	`16`	`+ SelectMacro.loopImpl[F]('pf, 'api, 'mc )`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`def runAsync(): F[Unit] =`