Scala: массивы и стирание типов

я думаю, что сигнатура второй функции после стирания типа должна быть (A: Array[Object])Unit not (t: Object)Unit, поэтому они не должны сталкиваться друг с другом. Я что-то упускаю?

стирание точно означает, что вы теряете любую информацию о параметрах типа универсального класса и получаете только необработанный тип. Итак, подпись def f[T](a: Array[T]) не может быть def f[T](a: Array[Object]) потому что у вас еще есть параметр типа (Object). Как правило, вам просто нужно чтобы удалить параметры типа, чтобы получить тип стирания, который даст нам def f[T](a: Array). Это будет работать для всех других универсальных классов, но массивы являются специальными для JVM,и, в частности, их уничтожение-это просто Object (ther нет array raw type). И таким образом, подпись f после стирания действительно def f[T](a: Object). [я был неправ] на самом деле после проверки спецификации java, кажется, что я был совершенно неправ здесь. Спецификация говорит

стирание массива типа T[] равно |T / []

здесь |T| - стирание T. Таким образом, массивы действительно обрабатываются специально, но особенность заключается в том, что в то время как параметры типа действительно удаляются, тип помечается как массив T вместо просто T. Это значит, что Array[Int] есть, после стирания все равно Array[Int]. Но!--14--> другое: T параметр типа для универсального метода f. Для того, чтобы иметь возможность лечить любые из массива в целом, у scala нет другого выбора, кроме поворота Array[T] на Object (и я полагаю, что Java делает то же самое, кстати). Это потому, что, как я сказал выше, нет такой вещи, как сырой тип Array, так и должно быть Object.

я попробую выразить это по-другому. Обычно при компиляции универсального метода с параметром типа MyGenericClass[T], сам факт того, что стертый тип MyGenericClass позволяет (на уровне JVM) передать любой экземпляр MyGenericClass, такие как MyGenericClass[Int] и MyGenericClass[Float], потому что они на самом деле все равно во время выполнения. Однако это не относится к массивам:Array[Int] является полностью несвязанным типом с Array[Float], и они не стираются до общего Array сырье тип. Их наименее распространенный тип -Object, и поэтому это то, что манипулируется под капотом, когда массивы обрабатываются обобщенно (everythime компилятор не может знать статически тип элементов).

обновление 2: ответ v6ak добавил полезный бит информации: Java не поддерживает примитивные типы в дженериках. Так Array[T], T обязательно (в Java, но не в Scala) подкласс Object и таким образом его стирания в Array[Object]полностью имеет смысл, в отличие от Scala, где T может быть примитивным типом Int, который определенно не sublclass из Object (Он же AnyRef). Чтобы быть в той же ситуации, что и Java, мы можем ограничить T С верхней границей и, конечно же, теперь он компилируется отлично:

def f[T](t: T) = println("normal type")
def f[T<:AnyRef](a: Array[T]) = println("Array type") // no conflict anymore

как можно обойти проблему, общее решение-добавить параметр манекен. Поскольку вы определенно не хотите явно передавать фиктивное значение при каждом вызове, вы можете либо дать ему фиктивное значение по умолчанию, либо использовать неявный параметр, который всегда будет неявно найден компилятором (например,dummyImplicit нашли в Predef):

def f[T](a: Array[T], dummy: Int = 0)
// or:
def f[T](a: Array[T])(implicit dummy: DummyImplicit)
// or:
def f[T:ClassManifest](a: Array[T])

[Scala 2.9] решением является использование неявных аргументов, которые естественным образом изменяют сигнатуру методов так, чтобы они не конфликтовали.

case class A()

def f[T](t: T) = println("normal type")
def f[T : Manifest](a: Array[T]) = println("Array type")

f(A())        // normal type
f(Array(A())) // Array type

T : Manifest является синтаксическим сахаром для второго списка аргументов (implicit mf: Manifest[T]).

к сожалению, я не знаю, почему Array[T] будет стерт просто Object вместо Array[Object].

чтобы преодолеть стирание типа в scala, вы можете добавить неявный параметр, который даст вам Манифест (scala 2.9.*) или TypeTag (scala 2.10), а затем вы можете получить всю необходимую информацию о типах, как в:

def f[T] (t: T) (неявный манифест: Манифест[T])

вы можете проверить, является ли M экземпляром массива и т. д.