removes array tags

Before 2.10 we had a notion of ClassManifest that could be used to retain
erasures of abstract types (type parameters, abstract type members) for
being used at runtime.

With the advent of ClassManifest (and its subtype Manifest)
it became possible to write:

  def mkGenericArray[T: Manifest] = Array[T]()

When compiling array instantiation, scalac would use a ClassManifest
implicit parameter from scope (in this case, provided by a context bound)
to remember Ts that have been passed to invoke mkGenericArray and
use that information to instantiate arrays at runtime (via Java reflection).

When redesigning manifests into what is now known as type tags, we decided
to explore a notion of ArrayTags that would stand for abstract and pure array
creators. Sure, ClassManifests were perfectly fine for this job, but they did
too much - technically speaking, one doesn't necessarily need a java.lang.Class
to create an array. Depending on a platform, e.g. within JavaScript runtime,
one would want to use a different mechanism.

As tempting as this idea was, it has also proven to be problematic.

First, it created an extra abstraction inside the compiler. Along with class tags
and type tags, we had a third flavor of tags - array tags. This has threaded the
additional complexity though implicits and typers.

Second, consequently, when redesigning tags multiple times over the course of
Scala 2.10.0 development, we had to carry this extra abstraction with us, which
exacerbated the overall feeling towards array tags.

Finally, array tags didn't fit into the naming scheme we had for tags.
Both class tags and type tags sound logical, because, they are descriptors for
the things they are supposed to tag, according to their names.
However array tags are the odd ones, because they don't actually tag any arrays.

As funny as it might sound, the naming problem was the last straw
that made us do away with the array tags. Hence this commit.

1 files changed, 23 insertions, 23 deletions

diff --git a/src/library/scala/Array.scala b/src/library/scala/Array.scala
index e7cf399fa4..6784b630c7 100644
--- a/src/library/scala/Array.scala
+++ b/src/library/scala/Array.scala
@@ -12,7 +12,7 @@ import scala.collection.generic._
 import scala.collection.{ mutable, immutable }
 import mutable.{ ArrayBuilder, ArraySeq }
 import compat.Platform.arraycopy
-import scala.reflect.ArrayTag
+import scala.reflect.ClassTag
 import scala.runtime.ScalaRunTime.{ array_apply, array_update }
 
 /** Contains a fallback builder for arrays when the element type
@@ -48,7 +48,7 @@ class FallbackArrayBuilding {
  *  @version 1.0
  */
 object Array extends FallbackArrayBuilding {
-  implicit def canBuildFrom[T](implicit t: ArrayTag[T]): CanBuildFrom[Array[_], T, Array[T]] =
+  implicit def canBuildFrom[T](implicit t: ClassTag[T]): CanBuildFrom[Array[_], T, Array[T]] =
     new CanBuildFrom[Array[_], T, Array[T]] {
       def apply(from: Array[_]) = ArrayBuilder.make[T]()(t)
       def apply() = ArrayBuilder.make[T]()(t)
@@ -57,7 +57,7 @@ object Array extends FallbackArrayBuilding {
   /**
    * Returns a new [[scala.collection.mutable.ArrayBuilder]].
    */
-  def newBuilder[T](implicit t: ArrayTag[T]): ArrayBuilder[T] = ArrayBuilder.make[T]()(t)
+  def newBuilder[T](implicit t: ClassTag[T]): ArrayBuilder[T] = ArrayBuilder.make[T]()(t)
 
   private def slowcopy(src : AnyRef,
                        srcPos : Int,
@@ -98,14 +98,14 @@ object Array extends FallbackArrayBuilding {
   }
 
   /** Returns an array of length 0 */
-  def empty[T: ArrayTag]: Array[T] = new Array[T](0)
+  def empty[T: ClassTag]: Array[T] = new Array[T](0)
 
   /** Creates an array with given elements.
    *
    *  @param xs the elements to put in the array
    *  @return an array containing all elements from xs.
    */
-  def apply[T: ArrayTag](xs: T*): Array[T] = {
+  def apply[T: ClassTag](xs: T*): Array[T] = {
     val array = new Array[T](xs.length)
     var i = 0
     for (x <- xs.iterator) { array(i) = x; i += 1 }
@@ -194,23 +194,23 @@ object Array extends FallbackArrayBuilding {
   }
 
   /** Creates array with given dimensions */
-  def ofDim[T: ArrayTag](n1: Int): Array[T] =
+  def ofDim[T: ClassTag](n1: Int): Array[T] =
     new Array[T](n1)
   /** Creates a 2-dimensional array */
-  def ofDim[T: ArrayTag](n1: Int, n2: Int): Array[Array[T]] = {
+  def ofDim[T: ClassTag](n1: Int, n2: Int): Array[Array[T]] = {
     val arr: Array[Array[T]] = (new Array[Array[T]](n1): Array[Array[T]])
     for (i <- 0 until n1) arr(i) = new Array[T](n2)
     arr
     // tabulate(n1)(_ => ofDim[T](n2))
   }
   /** Creates a 3-dimensional array */
-  def ofDim[T: ArrayTag](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] =
+  def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] =
     tabulate(n1)(_ => ofDim[T](n2, n3))
   /** Creates a 4-dimensional array */
-  def ofDim[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] =
+  def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] =
     tabulate(n1)(_ => ofDim[T](n2, n3, n4))
   /** Creates a 5-dimensional array */
-  def ofDim[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] =
+  def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] =
     tabulate(n1)(_ => ofDim[T](n2, n3, n4, n5))
 
   /** Concatenates all arrays into a single array.
@@ -218,7 +218,7 @@ object Array extends FallbackArrayBuilding {
    *  @param xss the given arrays
    *  @return   the array created from concatenating `xss`
    */
-  def concat[T: ArrayTag](xss: Array[T]*): Array[T] = {
+  def concat[T: ClassTag](xss: Array[T]*): Array[T] = {
     val b = newBuilder[T]
     b.sizeHint(xss.map(_.size).sum)
     for (xs <- xss) b ++= xs
@@ -239,7 +239,7 @@ object Array extends FallbackArrayBuilding {
    *  @return an Array of size n, where each element contains the result of computing
    *  `elem`.
    */
-  def fill[T: ArrayTag](n: Int)(elem: => T): Array[T] = {
+  def fill[T: ClassTag](n: Int)(elem: => T): Array[T] = {
     val b = newBuilder[T]
     b.sizeHint(n)
     var i = 0
@@ -257,7 +257,7 @@ object Array extends FallbackArrayBuilding {
    *  @param   n2  the number of elements in the 2nd dimension
    *  @param   elem the element computation
    */
-  def fill[T: ArrayTag](n1: Int, n2: Int)(elem: => T): Array[Array[T]] =
+  def fill[T: ClassTag](n1: Int, n2: Int)(elem: => T): Array[Array[T]] =
     tabulate(n1)(_ => fill(n2)(elem))
 
   /** Returns a three-dimensional array that contains the results of some element
@@ -268,7 +268,7 @@ object Array extends FallbackArrayBuilding {
    *  @param   n3  the number of elements in the 3nd dimension
    *  @param   elem the element computation
    */
-  def fill[T: ArrayTag](n1: Int, n2: Int, n3: Int)(elem: => T): Array[Array[Array[T]]] =
+  def fill[T: ClassTag](n1: Int, n2: Int, n3: Int)(elem: => T): Array[Array[Array[T]]] =
     tabulate(n1)(_ => fill(n2, n3)(elem))
 
   /** Returns a four-dimensional array that contains the results of some element
@@ -280,7 +280,7 @@ object Array extends FallbackArrayBuilding {
    *  @param   n4  the number of elements in the 4th dimension
    *  @param   elem the element computation
    */
-  def fill[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T): Array[Array[Array[Array[T]]]] =
+  def fill[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T): Array[Array[Array[Array[T]]]] =
     tabulate(n1)(_ => fill(n2, n3, n4)(elem))
 
   /** Returns a five-dimensional array that contains the results of some element
@@ -293,7 +293,7 @@ object Array extends FallbackArrayBuilding {
    *  @param   n5  the number of elements in the 5th dimension
    *  @param   elem the element computation
    */
-  def fill[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T): Array[Array[Array[Array[Array[T]]]]] =
+  def fill[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T): Array[Array[Array[Array[Array[T]]]]] =
     tabulate(n1)(_ => fill(n2, n3, n4, n5)(elem))
 
   /** Returns an array containing values of a given function over a range of integer
@@ -303,7 +303,7 @@ object Array extends FallbackArrayBuilding {
    *  @param  f   The function computing element values
    *  @return A traversable consisting of elements `f(0),f(1), ..., f(n - 1)`
    */
-  def tabulate[T: ArrayTag](n: Int)(f: Int => T): Array[T] = {
+  def tabulate[T: ClassTag](n: Int)(f: Int => T): Array[T] = {
     val b = newBuilder[T]
     b.sizeHint(n)
     var i = 0
@@ -321,7 +321,7 @@ object Array extends FallbackArrayBuilding {
    *  @param   n2  the number of elements in the 2nd dimension
    *  @param   f   The function computing element values
    */
-  def tabulate[T: ArrayTag](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]] =
+  def tabulate[T: ClassTag](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]] =
     tabulate(n1)(i1 => tabulate(n2)(f(i1, _)))
 
   /** Returns a three-dimensional array containing values of a given function
@@ -332,7 +332,7 @@ object Array extends FallbackArrayBuilding {
    *  @param   n3  the number of elements in the 3rd dimension
    *  @param   f   The function computing element values
    */
-  def tabulate[T: ArrayTag](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T): Array[Array[Array[T]]] =
+  def tabulate[T: ClassTag](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T): Array[Array[Array[T]]] =
     tabulate(n1)(i1 => tabulate(n2, n3)(f(i1, _, _)))
 
   /** Returns a four-dimensional array containing values of a given function
@@ -344,7 +344,7 @@ object Array extends FallbackArrayBuilding {
    *  @param   n4  the number of elements in the 4th dimension
    *  @param   f   The function computing element values
    */
-  def tabulate[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T): Array[Array[Array[Array[T]]]] =
+  def tabulate[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T): Array[Array[Array[Array[T]]]] =
     tabulate(n1)(i1 => tabulate(n2, n3, n4)(f(i1, _, _, _)))
 
   /** Returns a five-dimensional array containing values of a given function
@@ -357,7 +357,7 @@ object Array extends FallbackArrayBuilding {
    *  @param   n5  the number of elements in the 5th dimension
    *  @param   f   The function computing element values
    */
-  def tabulate[T: ArrayTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T): Array[Array[Array[Array[Array[T]]]]] =
+  def tabulate[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T): Array[Array[Array[Array[Array[T]]]]] =
     tabulate(n1)(i1 => tabulate(n2, n3, n4, n5)(f(i1, _, _, _, _)))
 
   /** Returns an array containing a sequence of increasing integers in a range.
@@ -396,7 +396,7 @@ object Array extends FallbackArrayBuilding {
    *  @param f     the function that is repeatedly applied
    *  @return      the array returning `len` values in the sequence `start, f(start), f(f(start)), ...`
    */
-  def iterate[T: ArrayTag](start: T, len: Int)(f: T => T): Array[T] = {
+  def iterate[T: ClassTag](start: T, len: Int)(f: T => T): Array[T] = {
     val b = newBuilder[T]
 
     if (len > 0) {
@@ -475,7 +475,7 @@ object Array extends FallbackArrayBuilding {
  *  @define collectExample
  *  @define undefinedorder
  *  @define thatinfo the class of the returned collection. In the standard library configuration,
- *    `That` is either `Array[B]` if an ArrayTag is available for B or `ArraySeq[B]` otherwise.
+ *    `That` is either `Array[B]` if an ClassTag is available for B or `ArraySeq[B]` otherwise.
  *  @define zipthatinfo $thatinfo
  *  @define bfinfo an implicit value of class `CanBuildFrom` which determines the result class `That` from the current
  *    representation type `Repr` and the new element type `B`.