Experiment with path-dependent modularity

[Krever]

Currently WIO relies on Ctx type parameter to encapsulate some fixed types, like Event or State. Alternative design might use path-dependent types.

I briefly experimented with this at the very early stage of the project but it wasnt possible then due to to the constraints of the compiler. This might change with modularity improvement.

What I'm mostly concern about, without giving it a real try, is how to properly expose those type on the use site. Inside the WIO and evaluators, those types can be abstract but inside the runtime needs to know it - E.g. it has to have and use a codec for a specific event type. Similarly in WorkflowInstance.getState, the caller wants a specific state type that they can deal with

[krrish175-byte]

Hi @Krever, thanks for opening this issue and for the detailed context. I am planning to start contributing to the project and would like to begin by picking issues one by one, starting from the earliest/open ones and moving forward gradually.
Looking forward to your feedback as I get started.

[Krever]

Hey @krrish175-byte , thanks a lot for your interest! I suggest starting from the issues labeled as "good first issue". They are the ones most likely to result in merge.

This particular one is very research-y and I myself dont know what has to be done. Lets not tackle it for now.

[Krever]

For the record, this seems to compile:

package workflows4s.wio

import cats.effect.IO
import workflows4s.wio.internal.EventHandler


sealed trait WIO2[-In, +Err](tracked val ctx: WorkflowContext){
  type Out <: ctx.State
}

object WIO2 {

  trait RunIO[-In, +Err, Evt] extends WIO2[In, Err] {
    def buildIO: In => IO[Evt]
    def evtHandler: EventHandler[In, Either[Err, Out], ctx.Event, Evt]
  }

  object RunIO {
    def apply[In, Err, Evt](ctx: WorkflowContext): WIO2[In,Err](ctx) = new RunIO[In, Err, Evt] with WIO2[In, Err](ctx) {
      override def buildIO: In => IO[Evt] = ???
      override def evtHandler: EventHandler[In, Either[Err, Out], ctx.Event, Evt] = ???
    }
  }

}

The first caveat, IntelliJ seems to have 0 support for it.

[Krever]

And in the context of #59 ,

package workflows4s.wio

import cats.effect.IO
import workflows4s.wio.internal.EventHandler

trait WorkflowContext2 {
  type Event
  type State
  type Effect[T]

  extension [T](v: Effect[T]){
    def map[U](f: T => U): Effect[U]
  }


  type WIO[In, Err] = WIO2[In, Err](this)
}


sealed trait WIO2[-In, +Err](tracked val ctx: WorkflowContext2){
  type Out <: ctx.State
}

object WIO2 {

  abstract class RunIO[-In, +Err, Evt](tracked override val ctx: WorkflowContext2) extends WIO2[In, Err](ctx) {
    def buildIO: In => ctx.Effect[Evt]
    def evtHandler: EventHandler[In, Either[Err, Out], ctx.Event, Evt]
  }

  object RunIO {
    def apply[In, Err, Evt](ctx: WorkflowContext2)(buildIO_ : In => ctx.Effect[Evt]): WIO2[In,Err](ctx) = new RunIO[In, Err, Evt](ctx) {
      override def buildIO: In => ctx.Effect[Evt] = buildIO_
      override def evtHandler: EventHandler[In, Either[Err, Out], ctx.Event, Evt] = ???
    }
  }

}

object WC1 extends WorkflowContext2 {
  type Event = String
  type State = Int
  type Effect[T] = IO[T]
  extension [T](v: Effect[T]){
    def map[U](f: T => U): Effect[U] = v.map(f)
  }
}

val runIO: WC1.WIO[Int, String] = WIO2.RunIO[Int, String, String](WC1) { i => IO(s"Hello $i") }


class RunIOEvaluator {
  def run[In, Err](wio: WIO2[In, Err], in: In): wio.ctx.Effect[wio.ctx.Event] = {
    wio match {
      case wio: (WIO2.RunIO[In, Err, _] & wio.type) => wio.buildIO(in).map(wio.evtHandler.convert)
      case wio: WIO2.RunIO[In, Err, _] => ??? // bug in compiler
    }
  }
}

[Krever]

Tried to experiment a bit more but reached scala/scala3#25164. Will get back to it once fixed.