键入Dynamic如何工作以及如何使用它？

95

我听说Dynamic可以在Scala中进行动态键入。但是我无法想象它的外观或工作方式。

我发现一个人可以继承特质 Dynamic

class DynImpl extends Dynamic

该API说，人们可以这样使用它：

foo.method（“ blah”）~~> foo.applyDynamic（“ method”）（“ blah”）

但是当我尝试它不起作用时：

scala> (new DynImpl).method("blah")
<console>:17: error: value applyDynamic is not a member of DynImpl
error after rewriting to new DynImpl().<applyDynamic: error>("method")
possible cause: maybe a wrong Dynamic method signature?
              (new DynImpl).method("blah")
               ^

这是完全合乎逻辑的，因为在查看源代码之后，事实证明此特征完全是空的。没有applyDynamic定义方法，我无法想象如何自己实现。

有人可以告诉我要使它正常工作需要做什么吗？

scala 
— 菊宿
source

Answers:

188

Scalas类型Dynamic允许您在不存在的对象上调用方法，换句话说，它是动态语言中“缺少方法”的副本。

是正确的，scala.Dynamic没有任何成员，它只是一个标记接口-具​​体的实现由编译器填充。对于Scalas 字符串插值功能，有定义明确的规则来描述生成的实现。实际上，可以实现四种不同的方法：

  • selectDynamic -允许编写字段访问器： foo.bar
  • updateDynamic -允许编写字段更新： foo.bar = 0
  • applyDynamic -允许使用参数调用方法： foo.bar(0)
  • applyDynamicNamed -允许使用命名参数调用方法： foo.bar(f = 0)

要使用这些方法之一，编写一个扩展Dynamic并在其中实现方法的类就足够了：

class DynImpl extends Dynamic {
  // method implementations here
}

此外，还需要添加一个

import scala.language.dynamics

或设置编译器选项，-language:dynamics因为默认情况下该功能是隐藏的。

选择动态

selectDynamic是最容易实现的。编译器会将的翻译转换foo.bar为foo.selectDynamic("bar")，因此要求此方法具有一个参数列表，该参数列表应为String：

class DynImpl extends Dynamic {
  def selectDynamic(name: String) = name
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@6040af64

scala> d.foo
res37: String = foo

scala> d.bar
res38: String = bar

scala> d.selectDynamic("foo")
res54: String = foo

可以看到，也可以显式调用动态方法。

updateDynamic

因为updateDynamic用于更新值，所以此方法需要返回Unit。此外，编译器将要更新的字段的名称及其值传递给不同的参数列表：

class DynImpl extends Dynamic {

  var map = Map.empty[String, Any]

  def selectDynamic(name: String) =
    map get name getOrElse sys.error("method not found")

  def updateDynamic(name: String)(value: Any) {
    map += name -> value
  }
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@7711a38f

scala> d.foo
java.lang.RuntimeException: method not found

scala> d.foo = 10
d.foo: Any = 10

scala> d.foo
res56: Any = 10

该代码按预期工作-可以在运行时将方法添加到代码中。另一方面，代码不再是类型安全的，并且如果调用的方法不存在，则也必须在运行时进行处理。另外，由于无法创建应在运行时调用的方法，因此该代码没有动态语言有用。这意味着我们不能做类似的事情

val name = "foo"
d.$name

其中，d.$name将被转换成d.foo在运行时。但这并不是那么糟糕，因为即使在动态语言中，这也是一个危险的功能。

这里要注意的另一件事是，updateDynamic需要与一起实现selectDynamic。如果我们不这样做，将会得到一个编译错误-该规则类似于Setter的实现，仅当存在具有相同名称的Getter时，该规则才有效。

applyDynamic

调用带有参数的方法的能力由applyDynamic：

class DynImpl extends Dynamic {
  def applyDynamic(name: String)(args: Any*) =
    s"method '$name' called with arguments ${args.mkString("'", "', '", "'")}"
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@766bd19d

scala> d.ints(1, 2, 3)
res68: String = method 'ints' called with arguments '1', '2', '3'

scala> d.foo()
res69: String = method 'foo' called with arguments ''

scala> d.foo
<console>:19: error: value selectDynamic is not a member of DynImpl

方法的名称及其参数再次被分隔到不同的参数列表中。如果需要，我们可以使用任意数量的参数来调用任意方法，但是如果要调用不带任何括号的方法，则需要实现selectDynamic。

提示：也可以将apply-syntax与结合使用applyDynamic：

scala> d(5)
res1: String = method 'apply' called with arguments '5'

applyDynamicNamed

如果需要，最后一个可用的方法允许我们命名参数：

class DynImpl extends Dynamic {

  def applyDynamicNamed(name: String)(args: (String, Any)*) =
    s"method '$name' called with arguments ${args.mkString("'", "', '", "'")}"
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@123810d1

scala> d.ints(i1 = 1, i2 = 2, 3)
res73: String = method 'ints' called with arguments '(i1,1)', '(i2,2)', '(,3)'

在该方法中签名所不同的是applyDynamicNamed以下形式的期望的元组(String, A)，其中A为任意类型。

上述所有方法的共同点是可以对它们的参数进行参数化：

class DynImpl extends Dynamic {

  import reflect.runtime.universe._

  def applyDynamic[A : TypeTag](name: String)(args: A*): A = name match {
    case "sum" if typeOf[A] =:= typeOf[Int] =>
      args.asInstanceOf[Seq[Int]].sum.asInstanceOf[A]
    case "concat" if typeOf[A] =:= typeOf[String] =>
      args.mkString.asInstanceOf[A]
  }
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@5d98e533

scala> d.sum(1, 2, 3)
res0: Int = 6

scala> d.concat("a", "b", "c")
res1: String = abc

幸运的是，还可以添加隐式参数-如果我们添加TypeTag上下文绑定，则可以轻松检查参数的类型。最好的是，即使返回类型也是正确的-即使我们必须添加一些强制类型转换。

但是当无法找到解决此类缺陷的方法时，Scala不会是Scala。在我们的例子中，我们可以使用类型类来避免强制类型转换：

object DynTypes {
  sealed abstract class DynType[A] {
    def exec(as: A*): A
  }

  implicit object SumType extends DynType[Int] {
    def exec(as: Int*): Int = as.sum
  }

  implicit object ConcatType extends DynType[String] {
    def exec(as: String*): String = as.mkString
  }
}

class DynImpl extends Dynamic {

  import reflect.runtime.universe._
  import DynTypes._

  def applyDynamic[A : TypeTag : DynType](name: String)(args: A*): A = name match {
    case "sum" if typeOf[A] =:= typeOf[Int] =>
      implicitly[DynType[A]].exec(args: _*)
    case "concat" if typeOf[A] =:= typeOf[String] =>
      implicitly[DynType[A]].exec(args: _*)
  }

}

尽管该实现看起来不太好，但其功能不可质疑：

scala> val d = new DynImpl
d: DynImpl = DynImpl@24a519a2

scala> d.sum(1, 2, 3)
res89: Int = 6

scala> d.concat("a", "b", "c")
res90: String = abc

最重要的是，还可以Dynamic与宏结合使用：

class DynImpl extends Dynamic {
  import language.experimental.macros

  def applyDynamic[A](name: String)(args: A*): A = macro DynImpl.applyDynamic[A]
}
object DynImpl {
  import reflect.macros.Context
  import DynTypes._

  def applyDynamic[A : c.WeakTypeTag](c: Context)(name: c.Expr[String])(args: c.Expr[A]*) = {
    import c.universe._

    val Literal(Constant(defName: String)) = name.tree

    val res = defName match {
      case "sum" if weakTypeOf[A] =:= weakTypeOf[Int] =>
        val seq = args map(_.tree) map { case Literal(Constant(c: Int)) => c }
        implicitly[DynType[Int]].exec(seq: _*)
      case "concat" if weakTypeOf[A] =:= weakTypeOf[String] =>
        val seq = args map(_.tree) map { case Literal(Constant(c: String)) => c }
        implicitly[DynType[String]].exec(seq: _*)
      case _ =>
        val seq = args map(_.tree) map { case Literal(Constant(c)) => c }
        c.abort(c.enclosingPosition, s"method '$defName' with args ${seq.mkString("'", "', '", "'")} doesn't exist")
    }
    c.Expr(Literal(Constant(res)))
  }
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@c487600

scala> d.sum(1, 2, 3)
res0: Int = 6

scala> d.concat("a", "b", "c")
res1: String = abc

scala> d.noexist("a", "b", "c")
<console>:11: error: method 'noexist' with args 'a', 'b', 'c' doesn't exist
              d.noexist("a", "b", "c")
                       ^

宏为我们提供了所有的编译时保证，尽管在上述情况下它不是那么有用，但是对于某些Scala DSL来说它可能非常有用。

如果您想获得更多有关的信息，Dynamic则有更多资源：

— 菊宿
source
1
绝对是一个很好的答案，也是Scala Power的展示
— Herrington Darkholme，2014年
万一默认情况下隐藏了该功能，我不会称其为强大功能，例如可能是实验性的，或者不能与其他人很好地兼容，或者是吗？
— matanster 2015年
是否有有关Scala Dynamic性能的信息？我知道Scala反射很慢（因此出现Scala-macro）。使用Scala Dynamic是否会大大降低性能？
— windweller
1
@AllenNie正如您在我的答案中所看到的，有多种实现方法。如果使用宏，则不再有开销，因为动态调用是在编译时解决的。如果在运行时使用do check，则必须进行参数检查才能正确地分派到正确的代码路径。这应该不会比应用程序中的任何其他参数检查都要多。如果您使用反射，显然会增加开销，但您必须自己衡量它会使应用程序减慢的速度。
— kiritsuku 2015年
1
“宏为我们提供了所有编译时间保证” –这让我
— 震惊
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.