Praktyczne zastosowania typu dynamiczny Scala

Question

oprócz integracji z dynamicznych języków na JVM, jakie są inne potężne zastosowania w Dynamic type w statycznie wpisywanych języka jak Scala?

Answer 1

Chyba typ dynamiczny mogłyby zostać wykorzystane do realizacji kilku znalezionych w JRuby, Groovy lub innych dynamicznych języków JVM, jak i dynamicznego metaprogramowanie method_missing cech.

Na przykład tworząc dynamiczne zapytanie podobny do Active Record w szynach, gdzie nazwa metody z parametrami przetłumaczone na zapytania SQL w tle. Jest to użycie funkcji method_missing w Ruby. Coś jak to (w teorii - nie próbowano zaimplementować coś takiego):

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

Umożliwienie wykorzystania takiego, gdzie można wywołać metody „name” i „findByName” bez konieczności ich jednoznacznie zdefiniowane w klasie 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") 

Jeśli dynamiczny metaprogramming zostało do dodania, rodzaj dynamicznego byłyby potrzebne, aby umożliwić wywoływanie metod, które zostały dodane podczas wykonywania ..

Answer 2

można również użyć go do cukru składniowej na mapach:

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" 

Szczerze mówiąc to tylko zaoszczędzić parę klawiszy od:

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

Answer 3

Odersky mówi główną motywacją była integracja z dynamicznych języków: http://groups.google.com/group/scala-language/msg/884e7f9a5351c549

[edytuj] Martin dalsze potwierdza to here