如何在scala中使用自然转换在一个解释器中添加两个Algebras。

Question

假设我有两个数组，如何在一个解释器的覆盖应用方法中添加多个数组？

sealed trait OneAlgebra[A]

case class create() extends OneAlgebra[Unit]
case class update() extends OneAlgebra[Unit]


sealed trait TwoAlgebra[A]

case class add() extends TwoAlgebra[Unit]
case class delete() extends TwoAlgebra[Unit]

 // Interpreter 
def commonInterpreter: CommonAlgebra ~> IO = new (CommonAlgebra ~> IO) {

  override def apply[A](commonAlgebra: CommonAlgebra[A]): IO[A] = commonAlgebra match {
     case create => do something
     case delete => do something
  }
}

如何在一个解释器中的覆盖应用方法中添加多个数组？有什么建议吗？

Answer 1

有一种方案是为每一个解释器写一个解释器，然后将它们组成。

scala> val intp1 = new (OneAlgebra ~> IO){ 
     |   def apply[A](fa: OneAlgebra[A]) = fa match {
     |     case create() => IO(println("create"))
     |     case update() => IO(println("update"))
     |   }
     | }
val intp1: OneAlgebra ~> cats.effect.IO = $anon$1@35696757

scala> val intp2 = new (TwoAlgebra ~> IO){ 
     |   def apply[A](fa: TwoAlgebra[A]) = fa match {
     |     case add() => IO(println("add"))
     |     case delete() => IO(println("delete"))
     |   }
     | }
val intp2: TwoAlgebra ~> cats.effect.IO = $anon$1@53be89fb

scala> type CommonAlgebra[A] = EitherK[OneAlgebra, TwoAlgebra, A]
type CommonAlgebra

scala> val intp: CommonAlgebra ~> IO = intp1 or intp2
val intp: CommonAlgebra ~> cats.effect.IO = cats.arrow.FunctionK$$anon$2@434c79e3

scala> intp(EitherK(Left(create()))).unsafeRunSync
create