模式匹配失去了类型界限？

Question

Why isn't effects an Effect[A] ? The types should line up from foo .

http://scastie.org/20029

/***
scalaVersion := "2.11.8"

*/
trait Effect[A]

sealed trait ActionResult[+M, +A] {
}

sealed trait ModelUpdated[+M] extends ActionResult[M, Nothing] {
}

sealed trait HasEffect[+M, +A] extends ActionResult[M, A] {
}

sealed trait UpdateSilent

object ActionResult {

  case object NoChange extends ActionResult[Nothing, Nothing]

  final case class ModelUpdate[M](newModel: M) extends ModelUpdated[M]

  final case class ModelUpdateSilent[M](newModel: M) extends ModelUpdated[M] with UpdateSilent

  final case class EffectOnly[A](effect: Effect[A]) extends ActionResult[Nothing, A] with HasEffect[Nothing, A]

  final case class ModelUpdateEffect[M, A](newModel: M, effect: Effect[A]) extends ModelUpdated[M] with HasEffect[M, A]

  final case class ModelUpdateSilentEffect[M, A](newModel: M, effect: Effect[A])
    extends ModelUpdated[M] with HasEffect[M, A] with UpdateSilent

  def apply[M, A](model: Option[M], effect: Option[Effect[A]]): ActionResult[M, A] = (model, effect) match {
    case (Some(m), Some(e)) => ModelUpdateEffect(m, e)
    case (Some(m), None)    => ModelUpdate(m)
    case (None, Some(e))    => EffectOnly(e)
    case _                  => NoChange
  }
}

object Main {
  def foo[A, B]: ActionResult[A, B] = ???
  def dispatch[A, B] = {
    foo[A, B] match {
      case ActionResult.NoChange =>
        false
      case ActionResult.ModelUpdate(newModel) =>
        false
      case ActionResult.ModelUpdateSilent(newModel) =>
        true
      case ActionResult.EffectOnly(effects) =>
        true
      case ActionResult.ModelUpdateEffect(newModel, effects) =>
        val e: Effect[A] = effects
        false
      case ActionResult.ModelUpdateSilentEffect(newModel, effects: Effect[A]) =>
        true
    }

  }
}

Answer 1

I don't have an answer per say, but here are some thoughts. First of all, I've simplified and clarified your code example to minimize down to the problem:

trait Effect[A]
trait ActionResult[+M, +A]
trait ModelUpdated[+M] extends ActionResult[M, Nothing]
trait HasEffect[+M, +A] extends ActionResult[M, A]

case class ModelUpdateEffect[M, A](newModel: M, effect: Effect[A]) extends ModelUpdated[M] with HasEffect[M, A]

object Main {
  def foo[M, A]: ActionResult[M, A] = ???
  def dispatch[M, A] = {
    foo[M, A] match {
      case ModelUpdateEffect(newModel, effect) =>
        val e: Effect[A] = effect // does not compile                                                              
        false
      case _ => true
    }
  }
}

Let's note the error message we get for that line:

type mismatch;
 found   : Effect[Any]
 required: Effect[A]
Note: Any >: A, but trait Effect is invariant in type A.

It's kind of strange the compiler decides that effect has type Effect[Any] . But let's see what happens if we replace this definition:

case class ModelUpdateEffect[M, A](newModel: M, effect: Effect[A]) extends ModelUpdated[M] with HasEffect[M, A]

with this:

case class ModelUpdateEffect[M, A](newModel: M, effect: Effect[A]) extends HasEffect[M, A]

Now we get a different error message:

type mismatch;
 found   : Effect[?A1] where type ?A1 <: A (this is a GADT skolem)
 required: Effect[A]
Note: ?A1 <: A, but trait Effect is invariant in type A.

In this case, the types really don't match up right. Let's walk through it. We know from outside the case statement that we have an ActionResult[M, A] . But because of the covariance on the type param A , that ActionResult[M, A] may well be an ActionResult[M, B] forSome { type B <: A } . In other words, there may be some type B that is a sub-type of A , and foo[M, A] might return an ActionResult[M, B] . In which case, effect would be an Effect[B] , and because the type parameter for Effect is invariant, this type is not compatible with Effect[A] .