¿Scala tiene un operador de "prueba si coinciden"?

Question

Duplicar posible:
Scala: short form of pattern matching that returns Boolean

En mi código Scala estoy encontrando a mí mismo escribiendo a menudo cosas como la siguiente:

x match{ 
    case Type(params) => doStuffWith(params) 
    case _ => /* do nothing*/ 
} 

¿Existe ya algún operador predefinido para ¿hacer esto? Creo que sería mucho más claro si pudiera escribir cosas como:

if(x match Type(params)) { 
    doStuffWith(params) 
} 

esencialmente evitando el extraño caso contrario. También he tenido otras situaciones en las que ser capaz de verificar si algo coincide con un patrón en línea me ahorraría un par adicional de llaves.

Sé que este tipo de cosas solo podría ser más útil al escribir más código iterativo, pero Scala parece tener tantas características ocultas que me preguntaba si alguien tiene una solución simple para esto.

Answer 1

Usted podría lift una función parcial del Any a A en una función a partir de Any a Option[A].

Para hacer el buen sintaxis definir en primer lugar una función auxiliar:

def lifted[A](pf: PartialFunction[Any,A]) = pf.lift 

A continuación, obtener beneficios:

val f = lifted { 
    case Type(i) => doStuff(i) 
} 

scala> f(2) 
res15: Option[Int] = None 

scala> f(Type(4)) 
res16: Option[Int] = Some(8) 

El método doStuff se llamará sólo si coincide con el argumento. Y puedes tener varias cláusulas de casos.

Answer 2

El camino más corto que puedo pensar es envolver el valor de una opción y utilizar el método de cobro revertido:

Option(x).collect { case Type(params) => doStuffWith(params) } 

Answer 3

Usando el enlace que @ phant0m dio, que explicarlo:

import PartialFunction.condOpt 

condOpt(x){ case Type(params) => doStuffWith(params) } 

Answer 4

Si este patrón aparece a menudo en su código, se debe considerar convertir doSomeStuff en un método de Type. Las clases de casos en Scala son clases normales, y debe usar las características orientadas a objetos cuando tengan sentido.

De lo contrario, podría agregar un método en la parte superior de su jerarquía, suponiendo que todas las clases de caso extiendan un rasgo común. Por ejemplo:

class Base { 
    def whenType(f: (T1, T2) => Unit): Unit = this match { 
    case Type(t1, t2) => f(t1, t2) 
    case _ =>() 
    } 
} 

y luego se puede utilizar x whenType doSomeStuff