Scala：错误类型不匹配

Question

I am struggling with the type system. I get a "error: type mismatch" at the line

handler.addJob(job1)

It says found "MessageEvent" required "Event"

I think that I need to somehow change the addJob method to pass in any Job with a type that extends Event but I can't figure out how to do that.

Also the line

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

should probably take a job with a subtype of Event but again I don't know how to do that. Any help is appreciated.

-Eric

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

The problems you mention are easy to fix:

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

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

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

But this shows another problem with the receive method: you need each job to process any Event . This can be fixed using Manifest s to work around type erasure:

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

Changing addJobs :

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

But jobs won't work with that, since Job[MessageEvent] is not a Job[Event] . The only way to get that is to make Job co-variant, but, unfortunately, you can't make Job co-variant as it is.

Why don't you, instead, completely removes Job 's parameterization and use Event internally? You can then use T <: Event (like above in addJob ) with addStep and processEvent , if necessary.

Answer 3

Based on your example, it looks as though you'll be building the Job and EventHandler instances statically. In this case, you really don't need those classes at all!

Starting with Job . This performs two roles:

1. maintain a list of T => Unit functions
2. execute those functions

(it's also worth noting that :: prepends, so steps will be executed in the reverse of the order they were added)

Building and maintaining that list of functions at runtime (within a mutable list) can be completely avoided if you already know what they'll be when the thing compiles. This is most naturally done with an aggregate function:

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

Instead of holding a List[Job[Event]] , this means that EventHandler now holds a List[(T => Unit)] (as Job previously did). So rinse and repeat...