Pourquoi une variable ne peut-elle pas être un identifiant stable ?

Question

Les

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

suivants

ne compile pas :

error : identifiant stable requis, mais cible trouvée. case target => println("C'était " + cible)

Pourquoi Scala a besoin d'un val et non d'un var. Je suppose que « Parce que » serait une réponse acceptable, mais j'ai le sentiment qu'il y a une raison plus profonde pour laquelle je manque.

Answer 1

Je soupçonne que c'est pour activer les optimisations de commutation de table pour les cas où c'est possible (sans piles de vérification pour voir si c'est valide). Par exemple, avec le code

class Sw {
  def m(i: Int) = {
    val a = 3
    val b = 2
    val c = 1
    i match {
      case `a` => 0
      case `b` => -1
      case `c` => 4
      case _ => 2
    }
  }
}

vous obtenez le bytecode

public int m(int);
  Code:
   0:   iconst_3
   1:   istore_2
   2:   iconst_2
   3:   istore_3
   4:   iconst_1
   5:   istore  4
   7:   iload_1
   8:   istore  5
   10:  iload   5
   12:  tableswitch{ //1 to 3
        1: 48;
        2: 44;
        3: 52;
        default: 40 }
   40:  iconst_2
   41:  goto    53
   44:  iconst_m1
   45:  goto    53
   48:  iconst_4
   49:  goto    53
   52:  iconst_0
   53:  ireturn

ce qui serait beaucoup plus compliqué si vous utilisiez vars (vous deviez détecter s'ils avaient changé pour savoir si cette expression de table était toujours valide).

Answer 2

Il n'y a rien pour vous empêcher de transformer votre var en val avant de l'utiliser dans le match :

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

fonctionne parfaitement bien.