Le classiche di scala sono di prima classe?

Question

È possibile passare modelli di caso come parametri ad altre funzioni? Qualcosa del genere:

def foo(pattern: someMagicType) { 
    x match { 
    pattern => println("match") 
    } 
} 

def bar() { 
    foo(case List(a, b, c)) 
} 

Answer 1

penso prima risposta di Kim Stebel è vicino a ciò che si desidera. Un 'pattern match as such' non è un'entità isolata in Scala. Una corrispondenza può essere definita come a Function1 o PartialFunction.

def foo[A, B](x: A)(pattern: PartialFunction[A, B]): Unit = 
    if(pattern.isDefinedAt(x)) println("match") 

def bar(list: List[String]): Unit = 
    foo(list){ case List("a", "b", "c") => } 

prova:

bar(Nil) 
bar(List("a", "b", "c")) 

usare alternativa composizione:

def foo[A, B](x: A)(pattern: PartialFunction[A, B]): Unit = { 
    val y = pattern andThen { _ => println("match")} 
    if (y.isDefinedAt(x)) y(x) 
} 

Answer 2

Quindi si desidera passare un blocco di corrispondenza del modello a un'altra funzione? Questo può essere fatto con PartialFunction s, come nell'esempio seguente:

def foo(f:PartialFunction[String, Int]) = { 
    f("") 
} 

foo { 
    case "" => 0 
    case s => s.toInt 
} 

Answer 3

Il tipo di magia può essere scritto come un tipo strutturale che ha un metodo unapply. A seconda del tipo di estrattore necessario, sono necessari diversi tipi di unapply o unapplySeq. Di seguito è un semplice esempio.

def foo(x:Int, Pattern: { def unapply(x:Int):Boolean }) { 
    x match { 
    case Pattern => println("match") 
    } 
} 

foo(1, new { def unapply(x:Int) = x > 0 }) 

e questo è come si fa per le liste:

foo(List(1,2,3), new { def unapplySeq(x:List[Int]):Option[List[Int]] = if (x.size >= 3) Some(x) else None }) 

def foo(x:List[Int], Pattern: { def unapplySeq(x:List[Int]):Option[List[Int]] }) { 
    x match { 
    case Pattern(a,b,c) => println("match: " + a + b + c) 
    } 
}