1 files changed, 0 insertions, 122 deletions
diff --git a/src/library/scalax/collection/generic/IterableFactory.scala b/src/library/scalax/collection/generic/IterableFactory.scala
deleted file mode 100755
index 0cf9c8ac95..0000000000
--- a/src/library/scalax/collection/generic/IterableFactory.scala
+++ /dev/null
@@ -1,122 +0,0 @@
-package scalax.collection.generic
-
-trait IterableFactory[CC[A] <: Iterable[A]] {
-
-  /** Create CC collection of specified elements */
-  def apply[A](args: A*): CC[A]
-
-  protected def newBuilder[A]: Builder[CC, A] =
-    apply().newBuilder[A].asInstanceOf[Builder[CC, A]]
-
-  // can't have an empty here because it is defined in subclass EmptyIterableFactory with type
-  // CC[Nothing]. This type does not make sense for immutable iterables.
-
-  /** Concatenate all the argument lists into a single list.
-   *
-   *  @param xss the lists that are to be concatenated
-   *  @return the concatenation of all the lists
-   */
-  def concat[A](xss: CC[A]*): CC[A] = {
-    val b = newBuilder[A]
-    for (xs <- xss) b ++= xs
-    b.result
-  }
-
-  /** An iterable that contains the same element a number of times
-   *  @param   n  The number of elements returned
-   *  @param   elem The element returned each time
-   */
-  def fill[A](n: Int)(elem: => A): CC[A] = {
-    val b = newBuilder[A]
-    var i = 0
-    while (i < n) {
-      b += elem
-      i += 1
-    }
-    b.result
-  }
-
-  def fill[A](n1: Int, n2: Int)(elem: => A): CC[CC[A]] =
-    tabulate(n1)(_ => fill(n2)(elem))
-
-  def fill[A](n1: Int, n2: Int, n3: Int)(elem: => A): CC[CC[CC[A]]] =
-    tabulate(n1)(_ => fill(n2, n3)(elem))
-
-  def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A): CC[CC[CC[CC[A]]]] =
-    tabulate(n1)(_ => fill(n2, n3, n4)(elem))
-
-  def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A): CC[CC[CC[CC[CC[A]]]]] =
-    tabulate(n1)(_ => fill(n2, n3, n4, n5)(elem))
-
-  def tabulate[A](n: Int)(f: Int => A): CC[A] = {
-    val b = newBuilder[A]
-    var i = 0
-    while (i < n) {
-      b += f(i)
-      i += 1
-    }
-    b.result
-  }
-
-  def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) => A): CC[CC[A]] =
-    tabulate(n1)(i1 => tabulate(n2)(f(i1, _)))
-
-  def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A): CC[CC[CC[A]]] =
-    tabulate(n1)(i1 => tabulate(n2, n3)(f(i1, _, _)))
-
-  def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A): CC[CC[CC[CC[A]]]] =
-    tabulate(n1)(i1 => tabulate(n2, n3, n4)(f(i1, _, _, _)))
-
-  def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A): CC[CC[CC[CC[CC[A]]]]] =
-    tabulate(n1)(i1 => tabulate(n2, n3, n4, n5)(f(i1, _, _, _, _)))
-
-  /** Create a sequence of increasing integers in a range.
-   *
-   *  @param from the start value of the sequence
-   *  @param end the end value of the sequence
-   *  @return the sorted list of all from `from` (inclusive)
-   *  up to, but exclusding, `end`.
-   */
-  def range[A](start: Int, end: Int): CC[Int] = range(start, end, 1)
-
-  /** Create a sequence of increasing integers in a range.
-   *
-   *  @param from the start value of the sequence
-   *  @param end the end value of the sequence
-   *  @param step the increment value of successive elements
-   *  @return a list of values <code>from + n * step</code> for
-   *          increasing n. If `step > 0` the sequence terminates
-   *          with the largest value less than `end`. If `step < 0`
-   *          the sequence terminates with the smallest value greater than `end`.
-   *          If `step == 0`, an IllegalArgumentException is thrown.
-   */
-  def range(start: Int, end: Int, step: Int): CC[Int] = {
-    if (step == 0) throw new IllegalArgumentException("zero step")
-    val b = newBuilder[Int]
-    var i = start
-    while ((step <= 0 || i < end) && (step >= 0 || i > end)) {
-      b += i
-      i += step
-    }
-    b.result
-  }
-
-  /** Create a sequence by repeatedly applying a given function to a start value.
-   *
-   *  @param start the start value of the sequence
-   *  @param len   the length of the sequence
-   *  @param f     the function that's repeatedly applied
-   *  @return      the sequence with elements <code>(start, f(start), f(f(start)), ..., f<sup>len-1</sup>(start))</code>
-   */
-  def iterate(start: Int, len: Int)(f: Int => Int): CC[Int] = {
-    val b = newBuilder[Int]
-    var acc = start
-    var i = 0
-    while (i < len) {
-      b += acc
-      acc = f(acc)
-      i += 1
-    }
-    b.result
-  }
-}