Use explicit kinds for type parameters

Avoid errors after scala/scala3#9086

Author: smarter

src/main/scala/ProcessDSL.scala

@@ -59,17 +59,17 @@ case object RecY extends RecY[Unit]
 sealed abstract class RecZ[A]() extends RecVar[A]("Z")
 case object RecZ extends RecZ[Unit]
 
-case class Def[V <: ProcVar, A, P1 <: Process, P2 <: Process](name: V[A], pdef: A => P1, in: () => P2) extends Process
-case class Call[V <: ProcVar, A](procvar: V[A], arg: A) extends Process
+case class Def[V[X] <: ProcVar[X], A, P1 <: Process, P2 <: Process](name: V[A], pdef: A => P1, in: () => P2) extends Process
+case class Call[V[X] <: ProcVar[X], A](procvar: V[A], arg: A) extends Process
 
 case class >>:[P1 <: Process, P2 <: Process](p1: () => P1, p2: () => P2) extends Process
 
 package object dsl {
   /** Recursion: `P` loops on `V`, that represent a bound recursion variable. */
-  type Rec[V <: RecVar, P <: Process] = Def[V, Unit, P, P]
+  type Rec[V[X] <: RecVar[X], P <: Process] = Def[V, Unit, P, P]
 
   /** Loop on a recursion variable `V`, expected to be bound by [[Rec]].*/
-  type Loop[V <: RecVar] = Call[V, Unit]
+  type Loop[V[X] <: RecVar[X]] = Call[V, Unit]
 
   /** Execute `P1` and `P2` in parallel. */
   type Par[P1 <: Process, P2 <: Process] = Fork[P1] >>: P2
@@ -270,13 +270,13 @@ package object dsl {
     Yield[A](v)(Some(implicitly[YieldCtx[A]]))
   }
 
-  def pdef[V <: ProcVar, A, P1 <: Process, P2 <: Process](name: V[A])(pdef: A => P1)(in: => P2) = Def[V, A, P1, P2](name, pdef, () => in)
+  def pdef[V[X] <: ProcVar[X], A, P1 <: Process, P2 <: Process](name: V[A])(pdef: A => P1)(in: => P2) = Def[V, A, P1, P2](name, pdef, () => in)
 
-  def pcall[V <: ProcVar, A](name: V[A], arg: A) = Call[V,A](name, arg)
+  def pcall[V[X] <: ProcVar[X], A](name: V[A], arg: A) = Call[V,A](name, arg)
 
-  def rec[V <: RecVar, P <: Process](v: V[Unit])(p: => P): Rec[V, P] = Def[V, Unit, P, P](v, (x) => p, () => p)
+  def rec[V[X] <: RecVar[X], P <: Process](v: V[Unit])(p: => P): Rec[V, P] = Def[V, Unit, P, P](v, (x) => p, () => p)
 
-  def loop[V <: RecVar](v: V[Unit]): Loop[V] = Call[V, Unit](v, ())
+  def loop[V[X] <: RecVar[X]](v: V[Unit]): Loop[V] = Call[V, Unit](v, ())
 
   def eval(p: Process): Try[Unit] = Try(eval(Map(), Nil, p))