¿Scala tiene guardias?

Question

Empecé a aprender scala hace unos días y cuando lo aprendí, lo estoy comparando con otros functional programming idiomas como (Haskell, Erlang) con los que estaba familiarizado. ¿Scala tiene secuencias guard disponibles?

Revisé la coincidencia de patrones en Scala, pero ¿hay algún concepto equivalente a guardias con otherwise y todo?

Answer 1

Sí, usa la palabra clave if. Desde la sección Case Classes de una gira de Scala, cerca de la parte inferior:

def isIdentityFun(term: Term): Boolean = term match { 
    case Fun(x, Var(y)) if x == y => true 
    case _ => false 
} 

(Esto no se menciona en la página Pattern Matching, tal vez porque el Tour es una visión tan rápida.)

---

En Haskell, otherwise es en realidad una variable vinculada a True. Por lo tanto, no agrega ningún poder al concepto de coincidencia de patrones. Puede obtenerlo simplemente repitiendo su patrón inicial sin el protector:

// if this is your guarded match 
    case Fun(x, Var(y)) if x == y => true 
// and this is your 'otherwise' match 
    case Fun(x, Var(y)) if true => false 
// you could just write this: 
    case Fun(x, Var(y)) => false 

Answer 2

Sí, hay protectores de patrón. Se utilizan como esto:

def boundedInt(min:Int, max: Int): Int => Int = { 
    case n if n>max => max 
    case n if n<min => min 
    case n => n 
} 

Tenga en cuenta que en lugar de un -clause otherwise, sólo tiene que specifiy el patrón sin un protector.

Answer 3

La respuesta simple es no. No es exactamente lo que estás buscando (una coincidencia exacta para la sintaxis de Haskell). Se podría utilizar "compatibles" con la declaración de Scala con un guardia, y el suministro de un comodín, como:

num match { 
    case 0 => "Zero" 
    case n if n > -1 =>"Positive number" 
    case _ => "Negative number" 
} 

Answer 4

me encontré con este post buscando la manera de aplicar los guardias de partidos con múltiples argumentos, no es muy intuitiva, por lo Estoy agregando un ejemplo al azar aquí.

def func(x: Int, y: Int): String = (x, y) match { 
    case (_, 0) | (0, _) => "Zero" 
    case (x, _) if x > -1 => "Positive number" 
    case (_, y) if y < 0 => "Negative number" 
    case (_, _) => "Could not classify" 
} 

println(func(10,-1)) 
println(func(-10,1)) 
println(func(-10,0))