Тип Scalas Dynamicпозволяет вам вызывать методы для объектов, которые не существуют, или, другими словами, это реплика «метод отсутствует» в динамических языках.
Он правильный, scala.Dynamicне имеет членов, это просто интерфейс-маркер - конкретная реализация заполняется компилятором. Что касается функции Scalas String Interpolation, существуют четко определенные правила, описывающие сгенерированную реализацию. Фактически, можно реализовать четыре разных метода:
selectDynamic - позволяет писать аксессоры полей: foo.barupdateDynamic - позволяет писать обновления полей: foo.bar = 0applyDynamic - позволяет вызывать методы с аргументами: foo.bar(0)applyDynamicNamed - позволяет вызывать методы с именованными аргументами: foo.bar(f = 0)
Чтобы использовать один из этих методов, достаточно написать расширяемый класс Dynamicи реализовать там методы:
class DynImpl extends Dynamic {
// method implementations here
}
Кроме того, нужно добавить
import scala.language.dynamics
или установите параметр компилятора, -language:dynamicsпотому что функция по умолчанию скрыта.
selectDynamic
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.
Подсказка: также можно использовать синтаксис применения с 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есть еще несколько ресурсов:
