Scala 中的动态属性

Question

Scala 支持动态属性之类的东西吗？示例：

val dog = new Dynamic // Dynamic does not define 'name' nor 'speak'.
dog.name = "Rex" // New property.
dog.speak = { "woof" } // New method.

val cat = new Dynamic
cat.name = "Fluffy"
cat.speak = { "meow" }

val rock = new Dynamic
rock.name = "Topaz"
// rock doesn't speak.

def test(val animal: Any) = {
   animal.name + " is telling " + animal.speak()
}

test(dog) // "Rex is telling woof"
test(cat) // "Fluffy is telling meow"
test(rock) // "Topaz is telling null"

我们在 Scala 中能得到的最接近的东西是什么？如果有像“addProperty”这样的东西允许像普通字段一样使用添加的属性，那就足够了。

我对结构类型声明（“类型安全鸭子类型”）不感兴趣。我真正需要的是在运行时添加新的属性和方法，以便该对象可以由期望添加的元素存在的方法/代码使用。

Answer 1

Scala 2.9 将有一个经过特殊处理的 Dynamic 特征，这可能正是您正在寻找的。

这个博客有很多关于它的内容：http://squirrelsewer.blogspot.com/2011/ 02/scalas-upcoming-dynamic-capability.html

我猜想在invokeDynamic方法中你需要检查“name_=”、“speak_=”、“name”和“speak”，你可以将值存储在私有映射中。

Answer 2

我想不出真正需要在运行时动态添加/创建方法/属性的原因除非也允许动态标识符 - 和/或 - 神奇的绑定到外部动态源（JRuby 或 JSON 是两个很好的例子）。

否则，发布的示例可以通过“匿名”类型和结构类型完全使用 Scala 中现有的静态类型来实现。不管怎样，并不是说“动态”不方便（正如 0__ 指出的那样，即将到来——随意“走边缘”；-）。

考虑一下：

val dog = new {
   val name = "Rex"
   def speak = { "woof" }
}

val cat = new {
   val name = "Fluffy"
   def speak = { "meow" }
}

// Rock not shown here -- because it doesn't speak it won't compile
// with the following unless it stubs in. In both cases it's an error:
// the issue is when/where the error occurs.

def test(animal: { val name: String; def speak: String }) = {
   animal.name + " is telling " + animal.speak
}

// However, we can take in the more general type { val name: String } and try to
// invoke the possibly non-existent property, albeit in a hackish sort of way.
// Unfortunately pattern matching does not work with structural types AFAIK :(

val rock = new {
   val name = "Topaz"
}

def test2(animal: { val name: String }) = {
   animal.name + " is telling " + (try {
       animal.asInstanceOf[{ def speak: String }).speak
   } catch { case _ => "{very silently}" })
}

test(dog)
test(cat)
// test(rock) -- no! will not compile (a good thing)
test2(dog)
test2(cat)
test2(rock)

但是，这种方法很快就会变得很麻烦（要“添加”新属性，需要创建一种新类型并将当前数据复制到其中），并且部分利用了示例代码的简单性。也就是说，实际上不可能以这种方式创建真正的“开放”对象；对于“开放”数据，某种 Map 可能是当前 Scala (2.8) 实现中更好/可行的方法。

快乐编码。

Answer 3

首先，正如 @pst 指出的，您的示例可以完全使用静态类型来实现，它不需要动态类型。

其次，如果您想使用动态类型语言进行编程，就使用动态类型语言进行编程。

话虽这么说，您实际上可以在 Scala 中做类似的事情。这是一个简单的例子：

class Dict[V](args: (String, V)*) extends Dynamic {
  import scala.collection.mutable.Map

  private val backingStore = Map[String, V](args:_*)

  def typed[T] = throw new UnsupportedOperationException()

  def applyDynamic(name: String)(args: Any*) = {
    val k = if (name.endsWith("_=")) name.dropRight(2) else name
    if (name.endsWith("_=")) backingStore(k) = args.first.asInstanceOf[V]
    backingStore.get(k)
  }

  override def toString() = "Dict(" + backingStore.mkString(", ") + ")"
}

object Dict {
  def apply[V](args: (String, V)*) = new Dict(args:_*)
}

val t1 = Dict[Any]()
t1.bar_=("quux")

val t2 = new Dict("foo" -> "bar", "baz" -> "quux")
val t3 = Dict("foo" -> "bar", "baz" -> "quux")

t1.bar // => Some(quux)
t2.baz // => Some(quux)
t3.baz // => Some(quux)

正如您所看到的，实际上您已经非常接近了。你的主要错误是 Dynamic 是一个特征，而不是一个类，所以你不能实例化它，你必须将它混合进去。而且你显然必须实际定义你想要它做什么，即实现typed 和applyDynamic。

如果您希望您的示例能够正常工作，那么会遇到一些复杂的情况。特别是，您需要诸如类型安全的异构映射之类的东西作为后备存储。此外，还有一些语法方面的考虑。例如，如果 foo.bar_= 存在，则 foo.bar = baz 仅翻译为 foo.bar_=(baz)，但事实并非如此不是，因为 foo 是一个 Dynamic 对象。