Как я могу различить def foo [A] (xs: A *) и def foo [A, B] (xs: (A, B) *)?
Вы делаете
printf ("Hi %s,</br />", $name);
перед установкой файлов cookie, что запрещено. Вы не можете отправить какой-либо вывод перед заголовками, даже пустую строку.
6 ответов
Можно, довольно окольным путем. Foo - это класс типов, и компилятор имплицитно передает экземпляр класса типов, совместимый с (выводимым) параметром типа A.
trait Foo[X] {
def apply(xs: Seq[X]): Unit
}
object Foo {
implicit def FooAny[A]: Foo[A] = new Foo[A] {
def apply(xs: Seq[A]) = println("apply(xs: Seq[A])")
}
implicit def FooTuple2[A, B]: Foo[(A, B)] = new Foo[(A, B)] {
def apply(xs: Seq[(A, B)]) = println("apply(xs: Seq[(A, B)])")
}
def apply[A](xs: A*)(implicit f: Foo[A]) = f(xs)
}
Foo(1, 2, 3) // apply(xs: Seq[A])
Foo(1 -> 2, 2 -> 3) // apply(xs: Seq[(A, B)])
Во втором вызове можно было бы передать и FooAny, и FooTuple2, но компилятор выбирает FooTuple2, основываясь на правилах статической перегрузки методов. FooTuple2 считается более конкретным, чем FooAny. Если два кандидата считаются такими же специфичными, как и друг друга, возникает ошибка неоднозначности. Вы также можете предпочесть один из них другому, поместив один из них в суперкласс, как это сделано в scala.LowPriorityImplicits.
UPDATE
Отталкиваясь от идеи DummyImplicit и последующей темы на scala-user:
trait __[+_]
object __ {
implicit object __ extends __[Any]
}
object overload {
def foo(a: Seq[Boolean]) = 0
def foo[_: __](a: Seq[Int]) = 1
def foo[_: __ : __](a: Seq[String]) = 2
}
import overload._
foo(Seq(true))
foo(Seq(1))
foo(Seq("s"))
Здесь объявляется параметризованный по типу признак __, ковариантный в своем неназванном параметре типа _. Его объект-компаньон __ содержит неявный экземпляр __[Any], который понадобится нам позже. Вторая и третья перегрузки foo включают параметры фиктивного типа, опять же безымянного. Он будет определяться как Any. Этот параметр типа имеет одну или несколько контекстных границ, которые десуггерируются в дополнительные неявные параметры, например:
def foo[A](a: Seq[Int])(implicit ev$1: __[A]) = 1
В байткоде несколько списков параметров объединяются в один список параметров, так что проблема двойного определения обходится.
Пожалуйста, рассматривайте это как возможность узнать о стирании, контекстных границах и неявном поиске, а не как образец для применения в реальном коде!
Если вы не против потерять возможность вызова foo с нулевыми аргументами (пустой Seq, если хотите), то этот трюк может помочь:
def foo[A](x: A, xs: A*) { x::xs.foreach(println) }
def foo[A, B](x: (A, B), xs: (A, B)*) { (x::xs.toList).foreach(x => println(x._1 + " - " + x._2)) }
Я не могу проверить, работает сейчас (даже если он компилируется), но я думаю, что основная идея довольно проста для понимания: тип первого параметра не будет удален, поэтому компилятор может изменить это на основе этого.
К сожалению, это также не очень удобно, если у вас уже есть Seq и вы хотите передать его в foo.
Есть еще один хакерский способ заставить это работать: Приклеить несвязанный неявный аргумент к одному из методов:
class Bar {
def foo[A](xs: A*) { xs.foreach(println) }
def foo[A, B](xs: (A, B)*)(implicit s:String) { xs.foreach(x => println(x._1 + " - " + x._2)) }
}
implicit val s = ""
new Bar().foo(1,2,3,4)
//--> 1
//--> 2
//--> 3
//--> 4
new Bar().foo((1,2),(3,4))
//--> 1 - 2
//--> 3 - 4
class Bar {
def foo[A](xs: A*) { xs.foreach{
case (a,b) => println(a + " - " + b)
case a => println(a)}
}
}
Это позволит
bar.foo(1,2)
bar.foo(1->3,2->4)
Но также разрешит
bar.foo(1->2,5)
В случае, когда у нас есть только 2 перегрузки, мы можем упростить ответ Ландея и избежать необходимости определять наш собственный implicit, используя scala.Predef.DummyImplicit, который автоматически импортируется в каждую область видимости для вас.
class Bar {
def foo[A](xs: A*) { xs.foreach(println) }
def foo[A, B](xs: (A, B)*)(implicit s:DummyImplicit){
xs.foreach(x => println(x._1 + " - " + x._2))
}
}
Кажется, меньше сложнее, чем метод ретронима , и является немного менее подробной (хотя и менее общей) версией решения DummyImplicit Кена Блума :
class Bar {
def foo[A : ClassManifest](xs: A*) = { xs.foreach(println) }
def foo[A : ClassManifest, B : ClassManifest](xs: (A, B)*) = {
xs.foreach(x => println(x._1 + " - " + x._2))
}
def foo[A : ClassManifest,
B : ClassManifest,
C : ClassManifest](xs: (A, B, C)*) = {
xs.foreach(x => println(x._1 + ", " + x._2 + ", " + x._3))
}
}
Этот метод также можно использовать, если у вас есть две перегрузки с такое же количество параметров типа:
class Bar {
def foo[A <: Int](xs: A*) = {
println("Ints:");
xs.foreach(println)
}
def foo[A <: String : ClassManifest](xs: A*) = {
println("Strings:");
xs.foreach(println)
}
}