在Scala中键入推理和模式加工

这不会输入：

sealed trait Binop[-InA,-InB,+Out]
case object Add extends Binop[Int,Int,Int]

sealed trait Expression[+A]
final case class IntegerAtom(value: Int) extends Expression[Int]
final case class BinaryExp[-A,-B,+C](op: Binop[A,B,C],lhs: Expression[A],rhs: Expression[B]) extends Expression[C]

def optimizeStep[A](x: Expression[A]): Expression[A] = x match {
  case BinaryExp(Add,IntegerAtom(a),IntegerAtom(b)) => IntegerAtom(a + b)
}

最直接的事情是在模式匹配中使用case对象：

[error] (...) pattern type is incompatible with expected type;
[error]  found   : minimumexample.Add.type
[error]  required: minimumexample.Binop[Any,Any,A]

这似乎可以通过引入眼睛出血来解决：

val AddOp = Add

然后：

case BinaryExp(AddOp,IntegerAtom(b)) => IntegerAtom(a + b)

但是之后：

[error] (...) type mismatch;
[error]  found   : minimumexample.IntegerAtom
[error]  required: minimumexample.Expression[A]
[error]     case BinaryExp(AddOp,IntegerAtom(b)) => IntegerAtom(a + b)
[error]                                                                         ^

我想尽可能安全地解决这个问题,而不是诉诸.asInstanceOf [].思考？

解决方法

您的代码的主要问题是BinaryExp定义中的差异问题,但这似乎不在问题的范围内.一旦你修正了方差,你就会遇到案例对象不引入新类型的唯一不便.

解决此问题的典型模式是声明一个密封特征,然后有一个案例对象来扩展它.

这是一个编译的例子

sealed trait Binop[-InA,+Out]
sealed trait Add extends Binop[Int,Int]
case object Add extends Add

sealed trait Expression[+A]
final case class IntegerAtom(value: Int) extends Expression[Int]
final case class BinaryExp[A,C](op: Binop[A,rhs: Expression[B]) extends Expression[C]

def optimizeStep[A](x: Expression[A]): Expression[A] = x match {
  case BinaryExp((_: Add),IntegerAtom(b)) => IntegerAtom(a + b)
}

哪里：

>方差以一种天真的方式“固定”(删除它)>由于密封的特性定义,Add现在是一个类型>使用(_：添加)执行匹配