scala - para - mendenhall probabilidad y estadistica pdf

Scala: ¿cómo no es segura la enumeración?

Question

He visto una serie de afirmaciones de que Scala Enumeration no es de tipo seguro. ¿Cómo no es seguro? Parece seguro de la forma obvia en que no puede pasar un valor de una enumeración a una enumeración diferente.

¿Cuáles son las trampas o las cosas que se deben evitar con la enumeración?

Answer 1

Es semi-seguro. Que sea de tipo seguro es una compilación de ficción, por lo que es fácil de romper. Por ejemplo,

trait Parent
class Boy extends Parent { override def toString = "boy" }
class Girl extends Parent { override def toString = "girl" }
def f(g: Girl) = g.toString

scala> f((new Boy).asInstanceOf[Girl])
java.lang.ClassCastException: Boy cannot be cast to Girl
    at .<init>(<console>:15)
    ...

Bien, los chicos no son chicas.

Ahora probemos con enumeraciones:

object Test extends Enumeration { val One, Two = Value }
object Probar extends Enumeration { val Uno, Dos = Value }
def h(tv: Test.Value) = tv.toString

scala> h((Probar.Uno).asInstanceOf[Test.Value])
res0: java.lang.String = Uno

¿Esperar lo?

Esta ficción conduce a otros comportamientos extraños:

def h(pv: Probar.Value) = pv.toString  // Add this to the other h in a :paste

method h:(pv: Probar.Value)java.lang.String and
method h:(tv: Test.Value)java.lang.String at line 9
have same type after erasure: (pv: Enumeration#Value)java.lang.String
           def h(pv: Probar.Value) = pv.toString

Uh, vale, gracias?

Y luego, dado que el compilador no entiende realmente la Enumeration como su propia construcción, no puede ayudarlo de la manera que podría esperar:

scala> def oops(tv: Test.Value) = tv match { case Test.One => "okay" }
oops: (tv: Test.Value)java.lang.String
// No incomplete match warning?  Okay....

scala> oops(Test.Two)
scala.MatchError: Two (of class scala.Enumeration$Val)
    at .oops(<console>:8)
    ...

Por lo tanto, si lo usa en formas relativamente limitadas exactamente según lo previsto, proporciona seguridad de tipo. Pero no tiene el poder y la robustez de otros patrones, como este:

// In REPL, :paste the next three lines
sealed trait Foo
object Bar extends Foo
object Baz extends Foo

scala> def safe(f: Foo) = f match { case Bar => "okay" }
<console>:9: warning: match is not exhaustive!
missing combination            Baz

        def safe(f: Foo) = f match { case Bar => "okay" }
                           ^

Gracias, compilador!