Extractor pattern matching in partial function

gistfile1.scala

object ExtractionTest extends Application {

  case object Message

  case class Event(event: Any, data: Int)

  def partialWithNormalCase: PartialFunction[Event, Int] = {
    case Event(Message, 1) => 1
    case Event(Message, 2) => 2
  }

  def partialWithCaseInExtractor: PartialFunction[Event, Int] = {
    case Event(Message, 1) => 1
    case MyExtractor() => 2
  }

  object MyExtractor {
    def unapply(event: Event) = {
      event match {
        case Event(Message, 2) => true
        case _ => false
      }
    }
  }

  val eventMessageTwo = Event(Message, 2)

  val definedInPartialNormal = partialWithNormalCase.isDefinedAt(eventMessageTwo)
  println("defined in normal: " + definedInPartialNormal)
  println("applied in normal: " + partialWithNormalCase.apply(eventMessageTwo))

  val definedInPartialWithExtractor = partialWithCaseInExtractor.isDefinedAt(eventMessageTwo)
  println("defined in extractor: " + definedInPartialWithExtractor)
  println("applied in extractor: " + partialWithCaseInExtractor.apply(eventMessageTwo))
}

gistfile2.scala

  def partialWithCaseInExtractor: PartialFunction[Event, Int] = {
    case MyExtractor() => 2
    case Event(Message, 1) => 1
  }

So, why doesn't first work, but if we change the partial function to the second example it does?
Why does the order matter when using regular cases in combination with extractors?

I haven't ruled out pilot error, but typed extractors have some nasty bugs: http://lampsvn.epfl.ch/trac/scala/ticket/1697

I kind of prefer writing functions from (A => Option[B]), and chaining them together with Scalaz,..

f >=> g >=> e