3

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

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 问题。那么有没有办法使用 Macros + Dynamics 来获得这样的东西？

编辑：基于@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
}

完整代码在这里

1）它正确处理字段与方法（甚至是 0-args），但非常冗长（目前最多只能使用 2 个 arg 方法）。有没有办法简化我的代码？

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

4

1 回答 1

8

为此，我们必须解决两个问题：

  1. 以某种方式将所有可能的函数统一为一种数据类型。
  2. 处理动态选择既可以返回值又可以返回函数的事实，我们无法提前确定。

这是一种可能性：

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

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

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

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不受其影响。

于 2013-09-01T11:46:24.690 回答