¿Cómo usar el interruptor/caja (coincidencia de patrón simple) en Scala?

Question

me he encontrado atrapado en una cosa muy trivial: -]

Tengo una enumeración:

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

En un código que tengo para convertirlo condicionalmente a un número (número varianr la correspondencia difiere según el contexto). Escribo:

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

Y esto me da un "código inalcanzable" error del compilador para cada rama, pero cualquiera que sea el primero ("caso FOO => 4" en este caso). ¿Qué estoy haciendo mal?

Answer 1

sospecho que el código que está utilizando realmente no es FOO, pero foo, minúsculas, lo que provocará Scala simplemente asignar el valor a foo, en lugar de comparar el valor a la misma.

En otras palabras:

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

el siguiente código funciona bien para mí: produce 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)) 
    } 
} 

puedes decir en qué se diferencia de su problema por favor?