Есть ли в Scala значительное влияние на ЦП или память при использовании неявных преобразований типов для расширения функциональности класса по сравнению с другими возможными вариантами реализации?
Например, рассмотрим глупую строку String функция манипуляции. Эта реализация использует конкатенацию строк:
object Funky {
def main(args: Array[String]) {
args foreach(arg => println("Funky " + arg))
}
}
Эта реализация скрывает конкатенацию за методом члена с помощью неявного преобразования типа:
class FunkyString(str: String) {
def funkify() = "Funky " + str
}
object ImplicitFunky {
implicit def asFunkyString(str: String) = new FunkyString(str)
def main(args: Array[String]) {
args foreach(arg => println(arg.funkify()))
}
}
Оба делают одно и то же:
scala> Funky.main(Array("Cold Medina", "Town", "Drummer"))
Funky Cold Medina
Funky Town
Funky Drummer
scala> ImplicitFunky.main(Array("Cold Medina", "Town", "Drummer"))
Funky Cold Medina
Funky Town
Funky Drummer
Есть ли разница в производительности? Несколько конкретных соображений:
Встраивает ли Scala неявные вызовы метода asFunkyString?
Действительно ли Scala создает новый объект-оболочку FunkyString для каждого аргумента или может оптимизировать выделение дополнительных объектов?
Предположим, FunkyString имел 3 разных метода (funkify1, funkify2 и funkify3), и тело foreach вызывало каждый из них последовательно:
println(arg.funkify1())
println(arg.funkify2())
println(arg.funkify3())
Будет ли Scala повторять преобразование 3 раза или оптимизировать избыточные преобразования и просто делать это один раз для каждого итерация цикла?
Предположим вместо этого, что я явно фиксирую преобразование в другой переменной, например:
val fs = asFunkyString(arg)
println(fs.funkify1())
println(fs.funkify2())
println(fs.funkify3())
Изменит ли это ситуацию?
На практике является ли широкое использование неявных преобразований потенциальной проблемой производительности или это обычно безвредно?