Scala：错误类型不匹配

Question

我正在与类型系统作斗争。我在该行收到“错误：类型不匹配”，

handler.addJob(job1)

它说 found "MessageEvent" required "Event"

我认为我需要以某种方式更改 addJob 方法才能传入任何具有扩展Event类型的Job，但我不知道如何做到这一点。

此外，该行

var jobs = List[Job[Event]]()

可能应该接受 Event 子类型的作业，但我又不知道该怎么做。任何帮助表示赞赏。

-埃里克

class EventHandler {
  var jobs = List[Job[Event]]()

  def receive(event: Event) {
    jobs.foreach {
      _.processEvent(event)
    }
  }

  def addJob(job: Job[Event]) {
    jobs = job :: jobs
  }
}

class Job[T <: Event] {
  var steps = List[(T => Unit)]()

  def addStep(step: (T => Unit)) {
    steps = step :: steps
  }

  def processEvent(event: T): Boolean = {
    steps.foreach(_.apply(event))
    return true
  }
}

class AppTest {
  def testApp {
    val handler = new EventHandler()
    val job1 = new Job[MessageEvent]
    job1.addStep {
      println(_)
    }
    handler.addJob(job1)
    handler.receive(new MessageEvent(new Message()))
  }
}

Answer 1

您提到的问题很容易解决：

class EventHandler {
  var jobs = List[Job[_]]()

  def receive(event: Event) {
    jobs.foreach {
      _.processEvent(event)
    }
  }

  def addJob(job: Job[_]) {
    jobs = job :: jobs
  }
}

但这显示了 receive 方法的另一个问题：您需要每个 job 来处理任何 Event。可以使用 Manifest 解决类型擦除问题：

class Job[T <: Event : ClassManifest] {
  val clazz: Class[T] = implicitly[ClassManifest[T]].asInstanceOf[Class[T]]
  var steps = List[(T => Unit)]()

  def addStep(step: (T => Unit)) {
    steps = step :: steps
  }

  def processEvent1(event: Event): Boolean = {
    try {
      processEvent(clazz.cast(event))
    }
    catch {
      case e: ClassCastException => false
    }
  }

  def processEvent(event: T): Boolean = {
    steps.foreach(_.apply(event))
    return true
  }
}

Answer 2

更改 addJobs：

def addJob[T <: Event](job: Job[T]) {
  jobs = job :: jobs
}

但是 jobs 不起作用，因为 Job[MessageEvent] 不是 Job[Event].实现这一点的唯一方法是使 Job 成为协变体，但不幸的是，您不能按原样使 Job 成为协变体。

为什么不完全删除 Job 的参数化并在内部使用 Event 呢？然后，如果需要，您可以将 T <: Event （如上面的 addJob）与 addStep 和 processEvent 一起使用。

Answer 3

根据您的示例，您似乎将静态构建 Job 和 EventHandler 实例。在这种情况下，你真的根本不需要这些课程！

从作业开始。这执行两个角色：

1. 维护 T => 的列表。 Unit 函数
2. 执行这些函数

（还值得注意的是 :: 前置，因此步骤将以与添加顺序相反的顺序执行）

如果您已经知道编译时它们会是什么，则可以完全避免在运行时维护该函数列表（在可变列表中）。这是最自然地使用聚合函数完成的：

val job = (m: MessageEvent) => {
  log.debug(m)
  println(m)
  somethingElse(m)
}

这意味着 EventHandler 现在持有一个 List[(T)，而不是持有一个 List[Job[Event]] => Unit)] （如 Job 之前所做的那样）。所以冲洗并重复...