我听说Dynamic
以某种方式可以在Scala中进行动态输入。但我无法想象这可能是什么样子或它是如何运作的。
我发现可以从特质Dynamic
class DynImpl extends Dynamic
API表示可以像这样使用它:
foo.method(“blah”)~~> foo.applyDynamic( “方法”)( “等等”)
但是当我尝试它时它不起作用:
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")
^
这是完全合乎逻辑的,因为在查看sources之后,结果证明这个特征是完全空的。没有定义applyDynamic
方法,我无法想象如何自己实现它。
有人能告诉我我需要做些什么才能让它发挥作用吗?
答案 0 :(得分:180)
Scalas类型Dynamic
允许您在不存在的对象上调用方法,换句话说,它是动态语言中“缺少方法”的副本。
这是正确的,scala.Dynamic
没有任何成员,它只是一个标记接口 - 具体实现由编译器填充。至于Scalas String Interpolation功能,有很好的定义规则描述了生成的实现。实际上,可以实现四种不同的方法:
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
用于更新值,因此此方法需要返回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
提供了使用参数调用方法的能力:
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
。
提示:也可以在applyDynamic
:
scala> d(5)
res1: String = method 'apply' called with arguments '5'
最后一个可用的方法允许我们在需要时命名我们的参数:
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
的更多信息,可以获得更多资源:
Dynamic
引入Scala 答案 1 :(得分:0)
kiritsuku 的回答更好。这是为了展示一个实用的 TL;DR 用例。
Dynamics 可用于使用构建器模式动态构造对象。
import scala.language.dynamics
case class DynImpl(
inputParams: Map[String, List[String]] = Map.empty[String, List[String]]
) extends Dynamic {
def applyDynamic(name: String)(args: String*): DynImpl = {
copy(inputParams = inputParams ++ Map(name -> args.toList))
}
}
val d1 = DynImpl().whatever("aaa", "bbb").cool("ccc")
println(d1.inputParams) // Map(whatever -> List(aaa, bbb), cool -> List(ccc))
val d2 = DynImpl().whatever("aaa", "bbb").fun("haha")
println(d2.inputParams) // Map(whatever -> List(aaa, bbb), fun -> List(haha))