Usos prácticos de un tipo dinámico en Scala

Question

Además de la integración con lenguajes dinámicos en la JVM, ¿cuáles son los otros usos potentes de un Dynamic type en un lenguaje estáticamente tipado como Scala?

Answer 1

Supongo que se podría utilizar un tipo dinámico para implementar varias de las funciones que se encuentran en JRuby, Groovy u otros lenguajes JVM dinámicos, como la metaprogramación dinámica y la eliminación de métodos.

Por ejemplo, crear una consulta dinámica similar a Active Record en Rails, donde un nombre de método con parámetros se traduce a una consulta SQL en segundo plano. Esto es usando la funcionalidad method_missing en Ruby. Algo como esto (en teoría - no han tratado de implementar algo así):

class Person(val id: Int) extends Dynamic { 
    def _select_(name: String) = { 
    val sql = "select " + name + " from Person where id = " id; 
    // run sql and return result 
    } 

    def _invoke_(name: String)(args: Any*) = { 
    val Pattern = "(findBy[a-zA-Z])".r 
    val sql = name match { 
     case Pattern(col) => "select * from Person where " + col + "='" args(0) + "'" 
     case ... 
    } 
    // run sql and return result 
    } 
} 

que permite el uso de este tipo, donde se puede llamar a los métodos 'nombre' y 'findByName' sin tener que definen explícitamente en la clase Person :

val person = new Person(1) 

// select name from Person where id = 1 
val name = person.name 

// select * from Person where name = 'Bob' 
val person2 = person.findByName("Bob") 

Si se añadirá a metaprogramming dinámico, sería necesario el tipo dinámico para permitir la invocación de métodos que se han añadido durante el tiempo de ejecución ..

Answer 2

es posible que también utilizarlo para el azúcar sintáctica en los mapas:

class DynamicMap[K, V] extends Dynamic { 
    val self = scala.collection.mutable.Map[K, V]() 
    def _select_(key: String) = self.apply(key) 
    def _invoke_(key: String)(value: Any*) = 
    if (value.nonEmpty) self.update(key, value(0).asInstanceOf[V]) 
    else throw new IllegalArgumentException 
} 

val map = new DynamicMap[String, String]() 

map.foo("bar") // adds key "foo" with value "bar"  
map.foo   // returns "bar" 

Para ser honesto, esto sólo le ahorra un par de pulsaciones de teclas a partir de:

val map = new Map[String, String]() 
map("foo") = "bar" 
map("foo") 

Answer 3

Odersky dice que la motivación principal fue la integración con lenguajes dinámicos: http://groups.google.com/group/scala-language/msg/884e7f9a5351c549

[editar] Martin confirma aún más este here