You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
106 lines
3.2 KiB
106 lines
3.2 KiB
package wow.doge.mygame
|
|
|
|
import cats.data.ReaderT
|
|
import monix.bio.UIO
|
|
import org.scalatest.funsuite.AnyFunSuite
|
|
import monix.execution.Scheduler.Implicits.global
|
|
import monix.bio.IO
|
|
import cats.mtl.Ask
|
|
import cats.mtl.implicits._
|
|
import cats.effect.LiftIO
|
|
import monix.bio.Task
|
|
import cats.data.Kleisli
|
|
import monix.bio.IOLift
|
|
|
|
class ReaderT_Test extends AnyFunSuite {
|
|
|
|
// type IoReaderT[S, E, A] = ReaderT[UIO, S, Either[E, A]]
|
|
// val IoReaderT = ReaderT
|
|
// val t =
|
|
// ReaderT[UIO, String, Either[Error, Unit]](s => UIO.unit.attempt)
|
|
// .run("s")
|
|
// .rethrow
|
|
// val r: IoReaderT[String, Error, Unit] = IoReaderT(s => UIO.unit.attempt)
|
|
// val t2 = r.run("s").rethrow
|
|
// Kleisli[IO, String, Unit](s => IO.unit)
|
|
|
|
case class Environment(str: String, num: Int)
|
|
|
|
// test("runReaderT_Test") {
|
|
// def fun1: ReaderT[UIO, String, Unit] = ReaderT(str => UIO(println(str)))
|
|
// def fun2: ReaderT[UIO, Int, Unit] = ReaderT(num => UIO(println(num)))
|
|
// def total: ReaderT[UIO, Environment, Unit] =
|
|
// for {
|
|
// _ <- fun1.local[Environment](_.str)
|
|
// _ <- fun2.local[Environment](_.num)
|
|
// } yield ()
|
|
|
|
// val uio: UIO[Unit] = total.run(Environment("hello", 50))
|
|
// uio.runSyncUnsafe()
|
|
// }
|
|
|
|
implicit val L =
|
|
new LiftIO[ReaderT[IO[String, ?], Environment, *]] {
|
|
|
|
override def liftIO[A](
|
|
ioa: cats.effect.IO[A]
|
|
): ReaderT[IO[String, ?], Environment, A] =
|
|
ReaderT(_ => IO.from(ioa).onErrorHandleWith(_ => IO.raiseError("whew")))
|
|
|
|
// override def liftIO[A](ioa: cats.effect.IO[A]): monix.bio.Task[A] =
|
|
// Task.from(ioa)
|
|
|
|
}
|
|
|
|
implicit val L2 = new IOLift[ReaderT[IO[String, ?], Environment, *]] {
|
|
|
|
override def apply[A](
|
|
task: monix.bio.Task[A]
|
|
): ReaderT[IO[String, ?], Environment, A] =
|
|
ReaderT(_ => IO.from(task).onErrorHandleWith(_ => IO.raiseError("whew")))
|
|
|
|
}
|
|
|
|
sealed trait AppError
|
|
|
|
type RIO[S, E, A] = ReaderT[IO[E, ?], S, A]
|
|
type EIO[S, A] = RIO[S, AppError, A]
|
|
type AppIO[A] = RIO[Environment, AppError, A]
|
|
|
|
test("2") {
|
|
def fun1: RIO[String, String, Unit] =
|
|
ReaderT(s => IO(println(s)).onErrorHandleWith(_ => IO.raiseError("wow")))
|
|
def fun2: ReaderT[IO[String, ?], Int, Unit] =
|
|
ReaderT(num =>
|
|
IO(println(num)).onErrorHandleWith(_ => IO.raiseError("whew"))
|
|
)
|
|
def fun3: ReaderT[IO[String, ?], Environment, Unit] =
|
|
for {
|
|
env <- ReaderT.ask[IO[String, ?], Environment]
|
|
} yield ()
|
|
def test[F[_]]()(implicit A: Ask[F, Int]) = A.ask[Int]
|
|
// def synctest[F[_]]
|
|
def fun4: ReaderT[IO[String, ?], Environment, Unit] =
|
|
for {
|
|
env <- ReaderT.ask[IO[String, ?], Environment]
|
|
_ <- ReaderT.liftF(
|
|
IO(println(env)).onErrorHandleWith(_ => IO.raiseError("wow"))
|
|
)
|
|
_ <- fun3
|
|
} yield ()
|
|
val topkek =
|
|
test[ReaderT[IO[String, ?], Int, *]]().local[Environment](_.num)
|
|
def app: ReaderT[IO[String, ?], Environment, Unit] =
|
|
for {
|
|
_ <- fun1.local[Environment](_.str)
|
|
_ <- fun2.local[Environment](_.num)
|
|
_ <- fun3
|
|
_ <- fun4
|
|
_ <- topkek
|
|
} yield ()
|
|
|
|
val io: IO[String, Unit] = app.run(Environment("hello", 50))
|
|
io.attempt.runSyncUnsafe()
|
|
}
|
|
|
|
}
|