Scala-Methoden mit generischem Parameter-Typ

Question

Ich arbeite seit fast einem Jahr mit Scala, aber ab und zu stoße ich auf einen Code, den ich nicht wirklich verstehe. Diesmal ist es dieser. Ich habe versucht, Dokumente über "Scala-Methoden mit generischem Parametertyp" zu untersuchen, aber ich bin immer noch verwirrt.

def defaultCall[T](featureName : String) (block : => Option[T])(implicit name: String, list:Seq[String]) : Option[T] = 
{ 
    val value = block match { 
    case Some(n) => n match { 
     case i : Integer => /*-------Call another method----*/ 
     case s : String => /*--------Call another method----*/ 
     } 
     case _ => None 
} 

Die Methode wird aufgerufen, unten mit dem Code:

var exValue = Some(10) 
val intialization = defaultCall[Integer]("StringName"){exValue} 

Was ich nicht verstehe, in der oben beschriebenen Code der „Fall“ Anweisung in der defaultCall Methode.

Ich sehe, dass, wenn der exValue einen Wert hat und nicht leer ist, der Code wie erwartet funktioniert. Aber wenn ich den exValue zu None ändere, dann geht mein Code in die Bedingung "case _ = None". Ich verstehe nicht, warum das passiert, da die Übereinstimmung, die hier gemacht wird, gegen die "Variable" ist, die entweder eine Ganzzahl oder ein String sein würde.

Answer 1

Was hier passiert, ist, dass, wenn Sie eine None gibt es auf dem zweiten Fall übereinstimmen, die „Fänge“ alles, was nicht eine Instanz ein some [T]:

block match { 
    case Some(n) => // Will match when you pass an instance of Some[T] 
    case _  => // Will match on any other case 
} 

Beachten Sie, dass keine und Einige sind zwei verschiedene Klassen, die von Option erben.

Die Variablenübereinstimmung wird auch nur durchgeführt, wenn die erste Übereinstimmung erfolgreich ist, andernfalls nicht. Um die Typprüfung im ersten Spiel erreichen Sie tun können:

block match { 
    case Some(n: Int) => // do stuff 
    case Some(n: String) => // do stuff 
    case _    => // Will match on any other case 
} 

Hoffnung, die