Question

我知道我可以像这样添加动态“字段”：

import collection.mutable

class DynamicType extends Dynamic {

  private val fields = mutable.Map.empty[String, Any].withDefault {key => throw new NoSuchFieldError(key)}

  def selectDynamic(key: String) = fields(key)

  def updateDynamic(key: String)(value: Any) = fields(key) = value

  def applyDynamic(key: String)(args: Any*) = fields(key)
}

然后我可以做这样的事情：

val foo = new DynamicType
foo.age = 23
foo.name = "Rick"

但是，我想进一步扩展这一步并添加动态方法，例如：

foo.greet = (name: String) => s"Nice to meet you $name, my name is ${this.name}"

foo.greet("Nat"); //should return "Nice to meet you Nat, my name is Rick"

我尝试将所有方法存储在updateDynamic的单独地图中，但我无法找到处理arity problem的通用方法。那么有没有办法使用宏+动力来制作这样的东西？

编辑：基于@Petr Pudlak的回答，我尝试实现这样的事情：

import collection.mutable
import DynamicType._

/**
 * An useful dynamic type that let's you add/delete fields and methods during runtime to a structure
 */
class DynamicType extends Dynamic {

  private val fields = mutable.Map.empty[String, Any] withDefault { key => throw new NoSuchFieldError(key) }
  private val methods = mutable.Map.empty[String, GenFn] withDefault { key => throw new NoSuchMethodError(key) }

  def selectDynamic(key: String) = fields(key)

  def updateDynamic(key: String)(value: Any) = value match {
    case fn0: Function0[Any] => methods(key) = {case Seq() => fn0()}
    case fn1: Function1[Any, Any] => methods(key) = fn1
    case fn2: Function2[Any, Any, Any] => methods(key) = fn2
    case _ => fields(key) = value
  }

  def applyDynamic(key: String)(args: Any*) = methods(key)(args)

  /**
   * Deletes a field (methods are fields too)
   * @return the old field value
   */
  def delete(key: String) = fields.remove(key)

  //todo: export/print to json
}

object DynamicType {
  import reflect.ClassTag

  type GenFn = PartialFunction[Seq[Any],Any]
  implicit def toGenFn1[A: ClassTag](f: (A) => Any): GenFn = { case Seq(a: A) => f(a) }
  implicit def toGenFn2[A: ClassTag, B: ClassTag](f: (A, B) => Any): GenFn = { case Seq(a: A, b: B) => f(a, b) }
  // todo: generalize to 22-args
}

Full code here

1）它正确处理字段与方法（甚至是0-args），但是非常冗长（目前仅适用于2个arg方法）。无论如何都要简化我的代码吗？

2）无论如何都支持动态方法重载（例如，添加2个具有不同签名的动态方法？）如果我可以获得该函数的签名，我可以将其用作methods映射中的键。

Answer 1

为了做到这一点，我们必须解决两个问题：

将所有可能的功能统一到一种数据类型中。
处理动态选择可以返回值和功能这一事实，我们无法提前确定。

这是一种可能性：

首先，让我们定义最通用的函数类型：获取任意数量的任何参数并产生结果，如果参数的数量或类型不对，则会失败。匹配：

type GenFn = PartialFunction[Seq[Any],Any]

现在我们创建一个动态类型，其中所有内容都是GenFn：

class DynamicType extends Dynamic {
  import collection.mutable

  private val fields =
    mutable.Map.empty[String,GenFn]
      .withDefault{ key => throw new NoSuchFieldError(key) }

  def selectDynamic(key: String) = fields(key)
  def updateDynamic(key: String)(value: GenFn) = fields(key) = value
  def applyDynamic(key: String)(args: Any*) = fields(key)(args);
}

接下来，让我们创建隐式转换，将不同arities的函数转换为此类型：

import scala.reflect.ClassTag
implicit def toGenFn0(f: => Any): GenFn =
  { case Seq() => f; }
implicit def toGenFn1[A: ClassTag](f: (A) => Any): GenFn =
  { case Seq(x1: A) => f(x1); }
implicit def toGenFn2[A: ClassTag,B: ClassTag](f: (A,B) => Any): GenFn =
  { case Seq(x1: A, x2: B) => f(x1, x2); }
// ... other arities ...

每次转换都会将一个函数（或一个值）转换为GenFn - 一个部分函数，如果它的参数数量/参数类型不正确，则会失败。我们使用ClassTag以便能够匹配正确类型的参数。请注意，我们将值视为零度函数。这样我们处理2.代价是通过在name()中给出零参数来检索值。

最后，我们可以做类似的事情：

val foo = new DynamicType
foo.name = "Rick"
foo.greet = (name: String) =>
    s"Nice to meet you $name, my name is ${foo.name()}"
println(foo.greet("Nat"));

为了支持方法重载，我们所需要的只是链PartialFunctions。这可以完成

  def updateDynamic(key: String)(value: GenFn) =
    fields.get(key) match {
      case None     => fields(key) = value
      case Some(f)  => fields(key) = f.orElse(value);
    }

（请注意，它不是线程安全的）。然后我们可以调用像

val foo = new DynamicType
foo.name = "Rick"
foo.greet = (name: String)
              => s"Nice to meet you $name, my name is ${foo.name()}"
foo.greet = (firstName: String, surname: String)
              => s"Nice to meet you $firstName $surname, my name is ${foo.name()}"
println(foo.greet("Nat"));
println(foo.greet("Nat Smith"));

请注意，此解决方案与标准方法重载的工作方式略有不同。这取决于添加函数的顺序。如果首先添加更通用的函数，则永远不会调用更具体的函数。因此，请先添加更多特定功能。

你完成它的方式可能会更加困难，因为你似乎没有区分功能的类型（比如我的toGenFn...方法），所以如果一个函数得到了错误的参数，它只是抛出一个异常，而不是将它们传递给下一个。但它应该适用于具有不同数量参数的函数。

我不认为可以避免因审查各种论点的功能而导致的冗长，但我认为这并不重要。这只是一次性工作，DynamicType的客户不受其影响。

Scala Dynamics：能够添加动态方法吗？

1 个答案: