40 votos

Usos prácticos de tipo dinámico en Scala

Además de la integración con lenguajes dinámicos en la JVM, ¿cuáles son los otros usos de gran alcance de tipo dinámico en una lengua estáticamente con tipos como Scala?

21voto

eivindw Puntos 843

Supongo que un tipo dinámico podría ser utilizado para implementar varias de las características que se encuentran en JRuby, Groovy o dinámica de la JVM idiomas, como dinámica de metaprogramación y method_missing.

Por ejemplo, la creación de una consulta dinámica similar a la de Registro Activo de Rieles, donde el nombre de un método con parámetros es traducido a una consulta SQL en el fondo. Este es el uso de la method_missing funcionalidad en Ruby. Algo como esto (en teoría - no se han tratado de implementar algo como esto):

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
  }
}

Permitiendo el uso de este, donde se puede llamar a los métodos de 'nombre' y 'findByName' sin haberlas definido explícitamente en la clase de Persona:

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 la dinámica de metaprogramación iba a ser añadido, el tipo Dinámico que sería necesario para permitir la invocación de los métodos que se han añadido durante el tiempo de ejecución..

6voto

IttayD Puntos 10490

Probablemente DSLs. Ver http://pastie.org/1468102

4voto

Adam Rabung Puntos 3014

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

[editar] Martin más confirma aquí

2voto

Knut Arne Vedaa Puntos 3878

También lo puede usar para "syntactic sugar" 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 sincero esto sólo le ahorra un par de pulsaciones de tecla de:

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

Iteramos.com

Iteramos es una comunidad de desarrolladores que busca expandir el conocimiento de la programación mas allá del inglés.
Tenemos una gran cantidad de contenido, y también puedes hacer tus propias preguntas o resolver las de los demás.

Powered by:

X