Wie funktioniert orElse arbeiten auf PartialFunctions

Gibt es ein paar Dinge, die falsch mit Ihrem Versuch, aber zuerst wollen wir sehen, eine funktionierende Implementierung:

scala> val a: PartialFunction[String, Unit] = { case "hello" => println("bye") }
a: PartialFunction[String,Unit] = <function1>

scala> val b: PartialFunction[Any, Unit] = { case _ => println("fallback") }
b: PartialFunction[Any,Unit] = <function1>

scala> val c = a.orElse(b)
c: PartialFunction[String,Unit] = <function1>

scala> c("hello")
bye

scala> c("foo")
fallback

Gibt es zwei wesentliche Fehler in deinem code:

1. die Art und Weise der PF definiert ist
2. die (falsche) Annahme, dass empty ist eine "catch-all" - Funktion, die zurück Nothing

1. Wie definieren Sie einen PartialFunction

val right: PartialFunction[String, Unit] = {
  case "hello" => println("bye")
}

Wie nicht, Sie zu definieren:

val wrong = PartialFunction[String, Unit] {
  case "hello" => println("bye")
}

Wenn man sich die definition von PartialFunction.apply

def apply[A, B](f: A => B): PartialFunction[A, B] = { case x => f(x) }

du wirst sehen, dass es definiert eine partielle Funktion für alle x und es gilt die angegebene f - Funktion. Jetzt ist Ihre { case "hello" => println("bye") } ist die f argument, so dass Sie etwa am Ende mit den folgenden (natürlich unerwartet) PartialFunction:

val wrong: PartialFunction[String, Unit] = {
  case x => x match {
    case "hello" => println("bye")  
  }

So, wenn Sie Sie Fragen, ob es definiert ist, es wird immer true zurück, da es definiert für alle string:

wrong.isDefinedAt("hello") //true (ok)
wrong.isDefinedAt("whatever") //true (sure?)

aber wenn Sie versuchen, um apply es

wrong("hello") //bye (ok)
wrong("whatever") //MatchError (BOOM!)

kurz auf die innere match.

Seit orElse entscheidet, ob Sie zum aufrufen der "andere" je nach Ergebnis der isDefined, dann ist es offensichtlich, warum es scheitert.

2. Leer, fängt nichts!

Direkt aus der docs:

def empty[A, B]: PartialFunction[A, B]

Die partielle Funktion mit leeren domain. Jeder Versuch zum aufrufen leere partielle Funktion führt zu werfen scala.MatchError Ausnahme.

Den PartialFunction (gut, es ist nicht wirklich teilweise mehr), die Sie suchen:

val fallback: PartialFunction[Any, Unit] = { case _ => println("fallback") }

oder - nur um zu zeigen, dass wir aus unseren Fehlern lernen -

val fallback = PartialFunction[Any, Unit] { _ => println("fallback") }

PartialFunction.empty[A,B] ist äquivalent zu:

{
  case x: Nothing => x
}

(Diese typechecks, weil Nothing ist ein Subtyp der beiden A und B.)

oder, was dasselbe ist:

{
  //note: this is probably not a valid Scala code for a partial function
  //but, as PartialFunction.empty's name suggests, it's an *empty* block
} 

Diese nicht mit etwas.

.orElse verstanden werden können einfach verkettet Listen von case-Anweisungen von zwei PartialFunctions. Also, in deinem Fall a.orElse(PartialFunction.empty[Any,Unit] bedeutet:

{ case "hello" => println("Bye") } orElse { /* no cases here */ }

vereinfacht zu:

{ case "hello" => println("Bye") }

oder

{ case "hello" => println("Bye"); case x:Nothing => x }

MatchError ist also offensichtlich.

Beachten Sie, dass die documetation auch erwähnt, dass empty wirft immer MatchError.

Aus dem, was ich denke, Sie wollte ein PartialFunction dass immer passt. Es gibt keine Methode mit dem Namen in der standard-Bibliothek für die, aber warum sollte es. Sie können einfach schreiben

{ case _ => () }