pattern - scala match

¿Por qué la coincidencia de patrones en Scala no funciona con variables?

Question

Tome la siguiente función:

def fMatch(s: String) = {
    s match {
        case "a" => println("It was a")
        case _ => println("It was something else")
    }
}

Este patrón combina muy bien:

scala> fMatch("a")
It was a

scala> fMatch("b")
It was something else

Lo que me gustaría poder hacer es lo siguiente:

def mMatch(s: String) = {
    val target: String = "a"
    s match {
        case target => println("It was" + target)
        case _ => println("It was something else")
        }
}

Esto produce el siguiente error:

fMatch: (s: String)Unit
<console>:12: error: unreachable code
               case _ => println("It was something else")

Supongo que esto es porque cree que el objetivo es en realidad un nombre que le gustaría asignar a cualquier entrada. Dos preguntas:

1. ¿Por qué este comportamiento? ¿No puede el caso simplemente buscar las variables existentes en el alcance que tienen el tipo apropiado y usarlas primero y, si no se encuentran, tratar el destino como un nombre para la coincidencia de patrones?

2. ¿Hay una solución para esto? ¿Hay alguna forma de emparejar patrones con variables? En última instancia, uno podría usar una gran afirmación if, pero el casillero es más elegante.

Answer 1

Lo que estás buscando es un identificador estable . En Scala, estos deben comenzar con una letra mayúscula, o estar rodeados por marcadores.

Ambas soluciones serían su problema:

def mMatch(s: String) = {
    val target: String = "a"
    s match {
        case `target` => println("It was" + target)
        case _ => println("It was something else")
    }
}

def mMatch2(s: String) = {
    val Target: String = "a"
    s match {
        case Target => println("It was" + Target)
        case _ => println("It was something else")
    }
}

Para evitar referencias accidentales a variables que ya existían en el ámbito adjunto, creo que tiene sentido que el comportamiento predeterminado sea que los patrones en minúsculas sean variables y no sean identificadores estables. Solo cuando veas algo que comienza con mayúsculas o minúsculas, debes ser consciente de que proviene del alcance circundante.