¿Cómo es una coincidencia de palabras omitidas en Scala?

Question

En Scala, que puede hacer

list.filter { item => 
    item match { 
     case Some(foo) => foo.bar > 0 
    } 
} 

Pero también se puede hacer la manera más rápida omitiendo match:

list.filter { 
    case Some(foo) => foo.bar > 0 
} 

¿Cómo se apoya en Scala? ¿Es esto nuevo en 2.9? Lo he estado buscando, y puedo descubrir qué hace esto posible. ¿Es solo parte del compilador de Scala?

Answer 1

La dirección language specification que en la sección 8.5.Las porciones relevantes:

una función anónima pueden ser de nida por una secuencia de casos

{ case p1 => b1 ... case pn => bn } 

Si el tipo esperado es scala.Functionk[S1, ..., Sk, R], la expresión se lleva a fi ser equivalente al anónimo función:

(x1 : S1, ..., xk : Sk) => (x1, ..., xk) match { 
    case p1 => b1 ... case pn => bn 
} 

Si el tipo esperado es scala.PartialFunction[S, R], la expresión se toma para sea equivalente a la siguiente expresión creación de la instancia:

new scala.PartialFunction[S, T ] { 
    def apply(x: S): T = x match { 
    case p1 => b1 ... case pn => bn 
    } 
    def isDefinedAt(x: S): Boolean = { 
    case p1 => true ... case pn => true 
    case _ => false 
    } 
} 

Así que escribir la expresión como PartialFunction o un Function influye en cómo se compila la expresión.

También trait PartialFunction [-A, +B] extends (A) ⇒ B por lo que una función parcial PartialFunction[A,B] también es Function[A,B].

Answer 2

Editar: partes de esta respuesta se equivocan; por favor, consulte huynhjl's answer.

---

Si se omite el match, que el compilador señal de que se está definiendo una función parcial. Una función parcial es una función que no está definida para cada valor de entrada. Por ejemplo, su función de filtro sólo se define por valores de tipo Some[A] (para el tipo personalizado A).

PartialFunction s arroja un MatchError cuando intentas aplicarlos donde no están definidos. Por lo tanto, usted debe asegurarse de que, cuando se pasa un PartialFunction donde se define un habitual Function, que su función parcial no será llamada con un argumento unhanded. Tal mecanismo es muy útil, p. para descomprimir tuplas de una colección:

val tupleSeq: Seq[(Int, Int)] = // ... 
val sums = tupleSeq.map { case (i1, i2) => i1 + i2 } 

API que piden una función parcial, al igual que la operación collect filtro-como en colecciones, por lo general isDefinedAt llamar antes de aplicar la función parcial. Allí, es seguro (y a menudo se desea) tener una función parcial que no está definida para cada valor de entrada.

Por lo tanto, puede ver que, aunque la sintaxis es similar a la de match, en realidad se trata de algo muy diferente.

Answer 3

- revisado después -

Hmm, no estoy seguro de que veo una diferencia, Scala 2.9.1.RC3,

val f: PartialFunction[Int, Int] = { case 2 => 3 } 
f.isDefinedAt(1) // evaluates to false 
f.isDefinedAt(2) // evaluates to true 
f(1) // match error 

val g: PartialFunction[Int, Int] = x => x match { case 2 => 3 } 
g.isDefinedAt(1) // evaluates to false 
g.isDefinedAt(2) // evaluates to true 
g(1) // match error 

Parece fg y se comportan exactamente el lo mismo que PartialFunctions.

Aquí hay otro ejemplo que demuestra la equivalencia:

Seq(1, "a").collect(x => x match { case s: String => s }) // evaluates to Seq(a) 

Aún más interesante:

// this compiles 
val g: PartialFunction[Int, Int] = (x: Int) => {x match { case 2 => 3 }} 

// this fails; found Function[Int, Int], required PartialFunction[Int, Int] 
val g: PartialFunction[Int, Int] = (x: Int) => {(); x match { case 2 => 3 }} 

Así que hay un poco de carcasa especial a nivel del compilador para convertir entre x => x match {...} y justo {...}.

actualización. Después de leer las especificaciones del lenguaje, esto me parece un error. Yo presenté SI-4940 en el seguimiento de errores.