dc10.cats.effect.CatsEffect.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of dc10-cats-effect_sjs1_3 Show documentation
Library for use with the `dc10-scala` code generator
The newest version!
package dc10.cats.effect

import cats.data.StateT
import dc10.scala.ErrorF
import dc10.scala.ctx.ext
import dc10.scala.Statement
import dc10.scala.Statement.{ObjectDef, TypeExpr, ValueDef, ValueExpr}
import dc10.scala.Symbol.{Object, Term}
import org.tpolecat.sourcepos.SourcePos

type IO[_]
type IOAPP

trait CatsEffect[F[_]]:
  def IO[A]: F[TypeExpr[IO[A], Unit]]
  def Io[A]: F[ValueExpr[IO[A], Unit]]
  extension [A] (io: F[ValueExpr[IO[A], Unit]])
    @scala.annotation.targetName("appVIO")
    def apply[Z](arg: F[ValueExpr[A, Z]]): F[ValueExpr[IO[A], (Unit, Z)]]
  def IOAPP(name: String, run: F[ValueExpr[IO[Unit], (Unit, Unit)]])(using sp: SourcePos): F[ValueExpr[IO[Unit], (Unit, Unit)]]
  def RUN(program: F[ValueExpr[IO[Unit], (Unit, Unit)]]): F[ValueExpr[IO[Unit], (Unit, Unit)]]
  extension [A] (io: F[TypeExpr[IO[A], Unit]])
    def PRINTLN(msg: F[ValueExpr[String, Unit]]): F[ValueExpr[IO[Unit], (Unit, Unit)]]

object CatsEffect:

  trait Mixins extends CatsEffect[[A] =>> StateT[ErrorF, List[Statement], A]]:
    def IO[A]: StateT[ErrorF, List[Statement], TypeExpr[IO[A], Unit]] =
      StateT.pure(TypeExpr(Term.TypeLevel.Var.UserDefinedType(None, "cats.effect.IO", None, Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ()))))
    def Io[A]: StateT[ErrorF, List[Statement], ValueExpr[IO[A], Unit]] =
      for
        t <- IO[A]
        v <- StateT.pure(ValueExpr(Term.ValueLevel.Var.UserDefinedValue(None, "cats.effect.IO", t.tpe, None)))
      yield v
    extension [A] (io: StateT[ErrorF, List[Statement], ValueExpr[IO[A], Unit]])
      @scala.annotation.targetName("appVIO")
      def apply[Z](arg: StateT[ErrorF, List[Statement], ValueExpr[A, Z]]): StateT[ErrorF, List[Statement], ValueExpr[IO[A], (Unit, Z)]] =
        ???
    def IOAPP(
      name: String,
      run: StateT[ErrorF, List[Statement], ValueExpr[IO[Unit], (Unit, Unit)]]
    )(using sp: SourcePos): StateT[ErrorF, List[Statement], ValueExpr[IO[Unit], (Unit, Unit)]] =
      for
        (c, r) <- StateT.liftF[ErrorF, List[Statement], (List[Statement], ValueExpr[IO[Unit], (Unit, Unit)])](run.runEmpty)
        o <- StateT.pure[ErrorF, List[Statement], Object[IOAPP, Unit]](
          Object(None, name, Some(Term.TypeLevel.Var.UserDefinedType(None, "cats.effect.IOApp.Simple", None, Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ()))), c.map(s => s.addIndent))
        )
        d <- StateT.pure[ErrorF, List[Statement], ObjectDef](ObjectDef(o, 0))
        _ <- StateT.modifyF[ErrorF, List[Statement]](ctx => ctx.ext(d))
      yield r

    def RUN(program: StateT[ErrorF, List[Statement], ValueExpr[IO[Unit], (Unit, Unit)]]): StateT[ErrorF, List[Statement], ValueExpr[IO[Unit], (Unit, Unit)]] =
      for
        i <- StateT.liftF(program.runEmptyA)
        v <- StateT.pure(Term.ValueLevel.Var.UserDefinedValue(None, "run", i.value.tpe, Some(i.value)))
        d <- StateT.pure[ErrorF, List[Statement], ValueDef](ValueDef.Val(0, v))
        _ <- StateT.modifyF[ErrorF, List[Statement]](ctx => ctx.ext(d))
      yield i
  
    extension [A] (io: StateT[ErrorF, List[Statement], TypeExpr[IO[A], Unit]])
      def PRINTLN(msg: StateT[ErrorF, List[Statement], ValueExpr[String, Unit]]): StateT[ErrorF, List[Statement], ValueExpr[IO[Unit], (Unit, Unit)]] =
        for
          s <- StateT.liftF(msg.runEmptyA)
          i <- IO[Unit]
          j <- Io[Unit]
          t <- StateT.pure[ErrorF, List[Statement], Term.TypeLevel[IO[Unit], (Unit, Unit)]](
            Term.TypeLevel.App.App1(None, i.tpe, Term.TypeLevel.Var.UnitType(None),
              Term.ValueLevel.App.AppCtor2(None, "",
                  Term.TypeLevel.App.App2(
                    None,
                    Term.TypeLevel.Var.TupleType(None, Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ())),
                    Term.TypeLevel.Var.UnitType(None),
                    s.value.tpe.dep.tpe,
                    s.value.tpe.dep.tpe.dep
                ),
                Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ()),
                Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ()),
              )
            )
          )
          v <- StateT.pure[ErrorF, List[Statement], ValueExpr[IO[Unit], (Unit, Unit)]](
            ValueExpr(
              Term.ValueLevel.App.App1(None,                
                Term.ValueLevel.Var.UserDefinedValue(None, "cats.effect.IO.println", Term.TypeLevel.Lam.Function1Type(None, 
                    Term.ValueLevel.App.AppCtor2(None, "",
                      Term.TypeLevel.App.App2(
                        None,
                        Term.TypeLevel.Var.TupleType(None, Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ())),
                        Term.TypeLevel.Var.UnitType(None),
                        s.value.tpe.dep.tpe,
                        s.value.tpe.dep.tpe.dep
                      ),
                      Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ()),
                      Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ()),
                    )
                  ), None
                ),
                s.value.manageDep(_ => 
                      Term.ValueLevel.App.AppCtor2(None, "",
                        Term.TypeLevel.App.App2(
                          None,
                          Term.TypeLevel.Var.TupleType(None, Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ())),
                          Term.TypeLevel.Var.UnitType(None),
                          s.value.tpe.dep.tpe,
                          s.value.tpe.dep.tpe.dep
                      ),
                      Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ()),
                      Term.ValueLevel.Var.UnitLiteral(None, Term.TypeLevel.Var.UnitType(None), ()),
                    )
                ),
                t
              )
            )
          )
        yield v