Comment utiliser switch/case (correspondance de motif simple) dans Scala?

Question

Je me suis trouvé coincé sur quelque chose de trivial: -]

J'ai un ENUM:

object Eny extends Enumeration { 
     type Eny = Value 
     val FOO, BAR, WOOZLE, DOOZLE = Value 
    } 

Dans un code que je dois le convertir sous condition à un certain nombre (varianr numéro la correspondance diffère selon le contexte). Je vous écris:

val en = BAR 
val num = en match { 
    case FOO => 4 
    case BAR => 5 
    case WOOZLE => 6 
    case DOOZLE => 7 
} 

Et cela me donne un « code injoignable » erreur du compilateur pour chaque branche, mais quel que soit le premier (« cas FOO => 4 » dans ce cas). Qu'est-ce que je fais mal?

Answer 1

Je soupçonne que le code que vous utilisez réellement n'est pas FOO, mais foo, minuscule, ce qui provoquera Scala juste assigner la valeur à foo, au lieu de comparer la valeur.

En d'autres termes:

x match { 
    case A => // compare x to A, because of the uppercase 
    case b => // assign x to b 
    case `b` => // compare x to b, because of the backtick 
} 

Answer 2

Le code suivant fonctionne bien pour moi: il produit 6

object Eny extends Enumeration { 
    type Eny = Value 
    val FOO, BAR, WOOZLE, DOOZLE = Value 
} 

import Eny._ 

class EnumTest { 
    def doit(en: Eny) = { 
     val num = en match { 
      case FOO => 4 
      case BAR => 5 
      case WOOZLE => 6 
      case DOOZLE => 7 
     }  

     num 
    } 
} 

object EnumTest { 
    def main(args: Array[String]) = { 
     println("" + new EnumTest().doit(WOOZLE)) 
    } 
} 

Pouvez-vous dire comment cela diffère de votre problème s'il vous plaît?