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

Toma 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 emite el siguiente error:

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

Supongo que esto se debe a que cree que target 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 tengan el tipo apropiado y usarlas primero y, si no se encuentra ninguna, luego tratar el objetivo como un nombre para hacer coincidir el patrón?

2. ¿Hay una solución para esto? ¿Alguna forma de hacer coincidir el patrón con las variables? En última instancia, uno podría usar una gran declaración if, pero el caso de coincidencia es más elegante.

Lo que busca es un identificador estable . En Scala, estos deben comenzar con una letra mayúscula o estar rodeados de comillas invertidas.

Ambos serían soluciones a 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 referirse accidentalmente 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 identificadores estables. Solo cuando vea algo que comience con mayúsculas o con tics posteriores, debe tener en cuenta que proviene del alcance circundante.