diff options
Diffstat (limited to 'src/library/scala')
82 files changed, 205 insertions, 2190 deletions
diff --git a/src/library/scala/Array.scala b/src/library/scala/Array.scala index 087fa07617..ae0dd68dfd 100644 --- a/src/library/scala/Array.scala +++ b/src/library/scala/Array.scala @@ -230,7 +230,7 @@ object Array extends FallbackArrayBuilding { * * Note that this means that `elem` is computed a total of n times: * {{{ - * scala> Array.fill(3){ java.lang.Math.random } + * scala> Array.fill(3){ math.random } * res3: Array[Double] = Array(0.365461167592537, 1.550395944913685E-4, 0.7907242137333306) * }}} * @@ -423,65 +423,6 @@ object Array extends FallbackArrayBuilding { if (x == null) None else Some(x.toIndexedSeq) // !!! the null check should to be necessary, but without it 2241 fails. Seems to be a bug // in pattern matcher. @PP: I noted in #4364 I think the behavior is correct. - - /** Creates an array containing several copies of an element. - * - * @param n the length of the resulting array - * @param elem the element composing the resulting array - * @return an array composed of n elements all equal to elem - */ - @deprecated("use `Array.fill` instead", "2.8.0") - def make[T: ClassManifest](n: Int, elem: T): Array[T] = { - val a = new Array[T](n) - var i = 0 - while (i < n) { - a(i) = elem - i += 1 - } - a - } - - /** Creates an array containing the values of a given function `f` - * over given range `[0..n)` - */ - @deprecated("use `Array.tabulate` instead", "2.8.0") - def fromFunction[T: ClassManifest](f: Int => T)(n: Int): Array[T] = { - val a = new Array[T](n) - var i = 0 - while (i < n) { - a(i) = f(i) - i += 1 - } - a - } - - /** Creates an array containing the values of a given function `f` - * over given range `[0..n1, 0..n2)` - */ - @deprecated("use `Array.tabulate` instead", "2.8.0") - def fromFunction[T: ClassManifest](f: (Int, Int) => T)(n1: Int, n2: Int): Array[Array[T]] = - fromFunction(i => fromFunction(f(i, _))(n2))(n1) - - /** Creates an array containing the values of a given function `f` - * over given range `[0..n1, 0..n2, 0..n3)` - */ - @deprecated("use `Array.tabulate` instead", "2.8.0") - def fromFunction[T: ClassManifest](f: (Int, Int, Int) => T)(n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] = - fromFunction(i => fromFunction(f(i, _, _))(n2, n3))(n1) - - /** Creates an array containing the values of a given function `f` - * over given range `[0..n1, 0..n2, 0..n3, 0..n4)` - */ - @deprecated("use `Array.tabulate` instead", "2.8.0") - def fromFunction[T: ClassManifest](f: (Int, Int, Int, Int) => T)(n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] = - fromFunction(i => fromFunction(f(i, _, _, _))(n2, n3, n4))(n1) - - /** Creates an array containing the values of a given function `f` - * over given range `[0..n1, 0..n2, 0..n3, 0..n4, 0..n5)` - */ - @deprecated("use `Array.tabulate` instead", "2.8.0") - def fromFunction[T: ClassManifest](f: (Int, Int, Int, Int, Int) => T)(n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] = - fromFunction(i => fromFunction(f(i, _, _, _, _))(n2, n3, n4, n5))(n1) } /** Arrays are mutable, indexed collections of values. `Array[T]` is Scala's representation @@ -529,38 +470,6 @@ object Array extends FallbackArrayBuilding { */ final class Array[T](_length: Int) extends java.io.Serializable with java.lang.Cloneable { - /** Multidimensional array creation */ - @deprecated("use `Array.ofDim` instead", "2.8.0") - def this(dim1: Int, dim2: Int) = this(dim1) - - /** Multidimensional array creation */ - @deprecated("use `Array.ofDim` instead", "2.8.0") - def this(dim1: Int, dim2: Int, dim3: Int) = this(dim1) - - /** Multidimensional array creation */ - @deprecated("use `Array.ofDim` instead", "2.8.0") - def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int) = this(dim1) - - /** Multidimensional array creation */ - @deprecated("use `Array.ofDim` instead", "2.8.0") - def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int) = this(dim1) - - /** Multidimensional array creation */ - @deprecated("use `Array.ofDim` instead", "2.8.0") - def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int) = this(dim1) - - /** Multidimensional array creation */ - @deprecated("use `Array.ofDim` instead", "2.8.0") - def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int, dim7: Int) = this(dim1) - - /** Multidimensional array creation */ - @deprecated("use `Array.ofDim` instead", "2.8.0") - def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int, dim7: Int, dim8: Int) = this(dim1) - - /** Multidimensional array creation */ - @deprecated("use `Array.ofDim` instead", "2.8.0") - def this(dim1: Int, dim2: Int, dim3: Int, dim4: Int, dim5: Int, dim6: Int, dim7: Int, dim8: Int, dim9: Int) = this(dim1) - /** The length of the array */ def length: Int = throw new Error() diff --git a/src/library/scala/Boolean.scala b/src/library/scala/Boolean.scala index f77bdd2ea0..dd5439d537 100755 --- a/src/library/scala/Boolean.scala +++ b/src/library/scala/Boolean.scala @@ -17,17 +17,93 @@ package scala * which provides useful non-primitive operations. */ final class Boolean extends AnyVal { + /** + * Negates a Boolean expression. + * + * - `!a` results in `false` if and only if `a` evaluates to `true` and + * - `!a` results in `true` if and only if `a` evaluates to `false`. + * + * @return the negated expression + */ def unary_! : Boolean = sys.error("stub") + /** + * Compares two Boolean expressions and returns `true` if they evaluate to the same value. + * + * `a == b` returns `true` if and only if + * - `a` and `b` are `true` or + * - `a` and `b` are `false`. + */ def ==(x: Boolean): Boolean = sys.error("stub") + + /** + * Compares two Boolean expressions and returns `true` if they evaluate to a different value. + * + * `a != b` returns `true` if and only if + * - `a` is `true` and `b` is `false` or + * - `a` is `false` and `b` is `true`. + */ def !=(x: Boolean): Boolean = sys.error("stub") + + /** + * Compares two Boolean expressions and returns `true` if one or both of them evaluate to true. + * + * `a || b` returns `true` if and only if + * - `a` is `true` or + * - `b` is `true` or + * - `a` and `b` are `true`. + * + * @note This method uses 'short-circuit' evaluation and + * behaves as if it was declared as `def ||(x: => Boolean): Boolean`. + * If `a` evaluates to `true`, `true` is returned without evaluating `b`. + */ def ||(x: Boolean): Boolean = sys.error("stub") + + /** + * Compares two Boolean expressions and returns `true` if both of them evaluate to true. + * + * `a && b` returns `true` if and only if + * - `a` and `b` are `true`. + * + * @note This method uses 'short-circuit' evaluation and + * behaves as if it was declared as `def &&(x: => Boolean): Boolean`. + * If `a` evaluates to `false`, `false` is returned without evaluating `b`. + */ def &&(x: Boolean): Boolean = sys.error("stub") + // Compiler won't build with these seemingly more accurate signatures // def ||(x: => Boolean): Boolean = sys.error("stub") // def &&(x: => Boolean): Boolean = sys.error("stub") + + /** + * Compares two Boolean expressions and returns `true` if one or both of them evaluate to true. + * + * `a | b` returns `true` if and only if + * - `a` is `true` or + * - `b` is `true` or + * - `a` and `b` are `true`. + * + * @note This method evaluates both `a` and `b`, even if the result is already determined after evaluating `a`. + */ def |(x: Boolean): Boolean = sys.error("stub") + + /** + * Compares two Boolean expressions and returns `true` if both of them evaluate to true. + * + * `a & b` returns `true` if and only if + * - `a` and `b` are `true`. + * + * @note This method evaluates both `a` and `b`, even if the result is already determined after evaluating `a`. + */ def &(x: Boolean): Boolean = sys.error("stub") + + /** + * Compares two Boolean expressions and returns `true` if they evaluate to a different value. + * + * `a ^ b` returns `true` if and only if + * - `a` is `true` and `b` is `false` or + * - `a` is `false` and `b` is `true`. + */ def ^(x: Boolean): Boolean = sys.error("stub") def getClass(): Class[Boolean] = sys.error("stub") diff --git a/src/library/scala/Cell.scala b/src/library/scala/Cell.scala deleted file mode 100644 index f1e7dc8d86..0000000000 --- a/src/library/scala/Cell.scala +++ /dev/null @@ -1,21 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala - -/** A `Cell` is a generic wrapper which completely - * hides the functionality of the wrapped object. The wrapped - * object is accessible via the `elem` accessor method. - * - * @author Martin Odersky - * @version 1.0, 08/08/2003 - */ -@deprecated("use `scala.Option` or `scala.Some` instead", "2.9.0") -case class Cell[+T](elem: T) diff --git a/src/library/scala/CountedIterator.scala b/src/library/scala/CountedIterator.scala deleted file mode 100644 index 6f2c597169..0000000000 --- a/src/library/scala/CountedIterator.scala +++ /dev/null @@ -1,24 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala - -/** Counted iterators keep track of the number of elements seen so far - * - * @since 2.0 - */ -@deprecated("use iterator.zipWithIndex instead", "2.8.0") -trait CountedIterator[+A] extends Iterator[A] { - /** counts the elements in this iterator; counts start at 0 - */ - def count: Int - - override def counted : this.type = this -} diff --git a/src/library/scala/Either.scala b/src/library/scala/Either.scala index e0f840a609..21d4d5c855 100644 --- a/src/library/scala/Either.scala +++ b/src/library/scala/Either.scala @@ -310,24 +310,6 @@ object Either { } } - @deprecated("use `x.joinLeft'", "2.8.0") - def joinLeft[A, B](es: Either[Either[A, B], B]) = - es.left.flatMap(x => x) - - @deprecated("use `x.joinRight'", "2.8.0") - def joinRight[A, B](es: Either[A, Either[A, B]]) = - es.right.flatMap(x => x) - - /** - * Takes an `Either` to its contained value within `Left` or - * `Right`. - */ - @deprecated("use `x.merge'", "2.8.0") - def merge[T](e: Either[T, T]) = e match { - case Left(t) => t - case Right(t) => t - } - /** If the condition satisfies, return the given `A` in `Left`, * otherwise, return the given `B` in `Right`. */ diff --git a/src/library/scala/Function.scala b/src/library/scala/Function.scala index 0e2d357892..23224b27e8 100644 --- a/src/library/scala/Function.scala +++ b/src/library/scala/Function.scala @@ -45,41 +45,6 @@ object Function { override def lift: T => Option[R] = f } - /** Currying for functions of arity 2. This transforms a function - * of arity 2 into a a unary function returning another unary function. - * - * @param f ... - * @return ... - */ - @deprecated("Use `f.curried` instead", "2.8.0") - def curried[a1, a2, b](f: (a1, a2) => b): a1 => a2 => b = { - x1 => x2 => f(x1, x2) - } - - /** Currying for functions of arity 3. - * - * @param f ... - * @return ... - */ - @deprecated("Use `f.curried` instead", "2.8.0") - def curried[a1, a2, a3, b](f: (a1, a2, a3) => b): a1 => a2 => a3 => b = { - x1 => x2 => x3 => f(x1, x2, x3) - } - - /** Currying for functions of arity 4. - */ - @deprecated("Use `f.curried` instead", "2.8.0") - def curried[a1, a2, a3, a4, b](f: (a1, a2, a3, a4) => b): a1 => a2 => a3 => a4 => b = { - x1 => x2 => x3 => x4 => f(x1, x2, x3, x4) - } - - /** Currying for functions of arity 5. - */ - @deprecated("Use `f.curried` instead", "2.8.0") - def curried[a1, a2, a3, a4, a5, b](f: (a1, a2, a3, a4, a5) => b): a1 => a2 => a3 => a4 => a5 => b = { - x1 => x2 => x3 => x4 => x5 => f(x1, x2, x3, x4, x5) - } - /** Uncurrying for functions of arity 2. This transforms a unary function * returning another unary function into a function of arity 2. */ diff --git a/src/library/scala/Function0.scala b/src/library/scala/Function0.scala index a3220f9752..f68bbcc454 100644 --- a/src/library/scala/Function0.scala +++ b/src/library/scala/Function0.scala @@ -6,7 +6,7 @@ ** |/ ** \* */ // GENERATED CODE: DO NOT EDIT. -// genprod generated these sources at: Thu Apr 14 13:08:25 PDT 2011 +// genprod generated these sources at: Sun Jul 31 00:37:30 CEST 2011 package scala diff --git a/src/library/scala/Function10.scala b/src/library/scala/Function10.scala index 632883f518..6f17606afd 100644 --- a/src/library/scala/Function10.scala +++ b/src/library/scala/Function10.scala @@ -26,8 +26,6 @@ trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 10 arguments, * it accepts a single [[scala.Tuple10]] argument. diff --git a/src/library/scala/Function11.scala b/src/library/scala/Function11.scala index 1c27ac757c..7a73bd35bf 100644 --- a/src/library/scala/Function11.scala +++ b/src/library/scala/Function11.scala @@ -26,8 +26,6 @@ trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] ex def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 11 arguments, * it accepts a single [[scala.Tuple11]] argument. diff --git a/src/library/scala/Function12.scala b/src/library/scala/Function12.scala index 7f53d87b33..c099c0436a 100644 --- a/src/library/scala/Function12.scala +++ b/src/library/scala/Function12.scala @@ -26,8 +26,6 @@ trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 12 arguments, * it accepts a single [[scala.Tuple12]] argument. diff --git a/src/library/scala/Function13.scala b/src/library/scala/Function13.scala index 9e05c6c69a..f13db28f30 100644 --- a/src/library/scala/Function13.scala +++ b/src/library/scala/Function13.scala @@ -26,8 +26,6 @@ trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 13 arguments, * it accepts a single [[scala.Tuple13]] argument. diff --git a/src/library/scala/Function14.scala b/src/library/scala/Function14.scala index 5dae9116b3..d0345cc552 100644 --- a/src/library/scala/Function14.scala +++ b/src/library/scala/Function14.scala @@ -26,8 +26,6 @@ trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 14 arguments, * it accepts a single [[scala.Tuple14]] argument. diff --git a/src/library/scala/Function15.scala b/src/library/scala/Function15.scala index b50974a868..69ff039f5b 100644 --- a/src/library/scala/Function15.scala +++ b/src/library/scala/Function15.scala @@ -26,8 +26,6 @@ trait Function15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 15 arguments, * it accepts a single [[scala.Tuple15]] argument. diff --git a/src/library/scala/Function16.scala b/src/library/scala/Function16.scala index 2dc726126b..d544d89303 100644 --- a/src/library/scala/Function16.scala +++ b/src/library/scala/Function16.scala @@ -26,8 +26,6 @@ trait Function16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 16 arguments, * it accepts a single [[scala.Tuple16]] argument. diff --git a/src/library/scala/Function17.scala b/src/library/scala/Function17.scala index 520c9d1288..16c71e7ada 100644 --- a/src/library/scala/Function17.scala +++ b/src/library/scala/Function17.scala @@ -26,8 +26,6 @@ trait Function17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 17 arguments, * it accepts a single [[scala.Tuple17]] argument. diff --git a/src/library/scala/Function18.scala b/src/library/scala/Function18.scala index 8d72a3f487..dfd70c2353 100644 --- a/src/library/scala/Function18.scala +++ b/src/library/scala/Function18.scala @@ -26,8 +26,6 @@ trait Function18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 18 arguments, * it accepts a single [[scala.Tuple18]] argument. diff --git a/src/library/scala/Function19.scala b/src/library/scala/Function19.scala index 3990bc60d6..63decd03ad 100644 --- a/src/library/scala/Function19.scala +++ b/src/library/scala/Function19.scala @@ -26,8 +26,6 @@ trait Function19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 19 arguments, * it accepts a single [[scala.Tuple19]] argument. diff --git a/src/library/scala/Function2.scala b/src/library/scala/Function2.scala index 7d0b9a5195..a4ad87fa97 100644 --- a/src/library/scala/Function2.scala +++ b/src/library/scala/Function2.scala @@ -39,8 +39,6 @@ trait Function2[@specialized(scala.Int, scala.Long, scala.Double) -T1, @speciali def curried: T1 => T2 => R = { (x1: T1) => (x2: T2) => apply(x1, x2) } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 2 arguments, * it accepts a single [[scala.Tuple2]] argument. diff --git a/src/library/scala/Function20.scala b/src/library/scala/Function20.scala index 94fa1cf56e..7219c9be81 100644 --- a/src/library/scala/Function20.scala +++ b/src/library/scala/Function20.scala @@ -26,8 +26,6 @@ trait Function20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 20 arguments, * it accepts a single [[scala.Tuple20]] argument. diff --git a/src/library/scala/Function21.scala b/src/library/scala/Function21.scala index f41d8899fc..c7d55960db 100644 --- a/src/library/scala/Function21.scala +++ b/src/library/scala/Function21.scala @@ -26,8 +26,6 @@ trait Function21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T21) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 21 arguments, * it accepts a single [[scala.Tuple21]] argument. diff --git a/src/library/scala/Function22.scala b/src/library/scala/Function22.scala index c1b290ff33..196421c830 100644 --- a/src/library/scala/Function22.scala +++ b/src/library/scala/Function22.scala @@ -26,8 +26,6 @@ trait Function22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => T22 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T21, x22: T22) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 22 arguments, * it accepts a single [[scala.Tuple22]] argument. diff --git a/src/library/scala/Function3.scala b/src/library/scala/Function3.scala index 1b592f5c88..09a5aa5828 100644 --- a/src/library/scala/Function3.scala +++ b/src/library/scala/Function3.scala @@ -26,8 +26,6 @@ trait Function3[-T1, -T2, -T3, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => R = { (x1: T1) => (x2: T2) => (x3: T3) => apply(x1, x2, x3) } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 3 arguments, * it accepts a single [[scala.Tuple3]] argument. diff --git a/src/library/scala/Function4.scala b/src/library/scala/Function4.scala index bd1123276b..00da84636a 100644 --- a/src/library/scala/Function4.scala +++ b/src/library/scala/Function4.scala @@ -26,8 +26,6 @@ trait Function4[-T1, -T2, -T3, -T4, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => T4 => R = { (x1: T1) => (x2: T2) => (x3: T3) => (x4: T4) => apply(x1, x2, x3, x4) } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 4 arguments, * it accepts a single [[scala.Tuple4]] argument. diff --git a/src/library/scala/Function5.scala b/src/library/scala/Function5.scala index af83dcf303..3915048906 100644 --- a/src/library/scala/Function5.scala +++ b/src/library/scala/Function5.scala @@ -26,8 +26,6 @@ trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => T4 => T5 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5) => self.apply(x1, x2, x3, x4, x5)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 5 arguments, * it accepts a single [[scala.Tuple5]] argument. diff --git a/src/library/scala/Function6.scala b/src/library/scala/Function6.scala index caceb55c33..183a7332e1 100644 --- a/src/library/scala/Function6.scala +++ b/src/library/scala/Function6.scala @@ -26,8 +26,6 @@ trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => T4 => T5 => T6 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6) => self.apply(x1, x2, x3, x4, x5, x6)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 6 arguments, * it accepts a single [[scala.Tuple6]] argument. diff --git a/src/library/scala/Function7.scala b/src/library/scala/Function7.scala index 16aa9a90b6..10f8e9b599 100644 --- a/src/library/scala/Function7.scala +++ b/src/library/scala/Function7.scala @@ -26,8 +26,6 @@ trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends AnyRef { self => def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7) => self.apply(x1, x2, x3, x4, x5, x6, x7)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 7 arguments, * it accepts a single [[scala.Tuple7]] argument. diff --git a/src/library/scala/Function8.scala b/src/library/scala/Function8.scala index 6f97cc182b..8144b36101 100644 --- a/src/library/scala/Function8.scala +++ b/src/library/scala/Function8.scala @@ -26,8 +26,6 @@ trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends AnyRef { sel def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 8 arguments, * it accepts a single [[scala.Tuple8]] argument. diff --git a/src/library/scala/Function9.scala b/src/library/scala/Function9.scala index 3c39cb472b..ee04ed0915 100644 --- a/src/library/scala/Function9.scala +++ b/src/library/scala/Function9.scala @@ -26,8 +26,6 @@ trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends AnyRef def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9)).curried } - @deprecated("Use 'curried' instead", "2.8.0") - def curry = curried /** Creates a tupled version of this function: instead of 9 arguments, * it accepts a single [[scala.Tuple9]] argument. diff --git a/src/library/scala/Math.scala b/src/library/scala/Math.scala deleted file mode 100644 index 87db3ea877..0000000000 --- a/src/library/scala/Math.scala +++ /dev/null @@ -1,95 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - -package scala - -/** The object `Math` contains methods for performing basic numeric - * operations such as the elementary exponential, logarithm, square root, - * and trigonometric functions. - */ -@deprecated("use the scala.math package object instead.\n(Example package object usage: scala.math.Pi )", "2.8.0") -object Math extends MathCommon { - @deprecated("Use `scala.Byte.MinValue` instead", "2.8.0") - val MIN_BYTE = java.lang.Byte.MIN_VALUE - - @deprecated("Use `scala.Byte.MaxValue` instead", "2.8.0") - val MAX_BYTE = java.lang.Byte.MAX_VALUE - - @deprecated("Use `scala.Short.MinValue` instead", "2.8.0") - val MIN_SHORT = java.lang.Short.MIN_VALUE - - @deprecated("Use `scala.Short.MaxValue` instead", "2.8.0") - val MAX_SHORT = java.lang.Short.MAX_VALUE - - @deprecated("Use `scala.Char.MinValue` instead", "2.8.0") - val MIN_CHAR = java.lang.Character.MIN_VALUE - - @deprecated("Use `scala.Char.MaxValue` instead", "2.8.0") - val MAX_CHAR = java.lang.Character.MAX_VALUE - - @deprecated("Use `scala.Int.MinValue` instead", "2.8.0") - val MIN_INT = java.lang.Integer.MIN_VALUE - - @deprecated("Use `scala.Int.MaxValue` instead", "2.8.0") - val MAX_INT = java.lang.Integer.MAX_VALUE - - @deprecated("Use `scala.Long.MinValue` instead", "2.8.0") - val MIN_LONG = java.lang.Long.MIN_VALUE - - @deprecated("Use `scala.Long.MaxValue` instead", "2.8.0") - val MAX_LONG = java.lang.Long.MAX_VALUE - - /** The smallest possible value for [[scala.Float]]. */ - @deprecated("Use `scala.Float.MinValue` instead", "2.8.0") - val MIN_FLOAT = -java.lang.Float.MAX_VALUE - - /** The smallest difference between two values of [[scala.Float]]. */ - @deprecated("Use `scala.Float.MinPositiveValue` instead", "2.8.0") - val EPS_FLOAT = java.lang.Float.MIN_VALUE - - /** The greatest possible value for [[scala.Float]]. */ - @deprecated("Use `scala.Float.MaxValue` instead", "2.8.0") - val MAX_FLOAT = java.lang.Float.MAX_VALUE - - /** A value of type [[scala.Float]] that represents no number. */ - @deprecated("Use `scala.Float.NaN` instead", "2.8.0") - val NaN_FLOAT = java.lang.Float.NaN - - /** Negative infinity of type [[scala.Float]]. */ - @deprecated("Use `scala.Float.NegativeInfinity` instead", "2.8.0") - val NEG_INF_FLOAT = java.lang.Float.NEGATIVE_INFINITY - - /** Positive infinity of type [[scala.Float]]. */ - @deprecated("Use `scala.Float.PositiveInfinity` instead", "2.8.0") - val POS_INF_FLOAT = java.lang.Float.POSITIVE_INFINITY - - /** The smallest possible value for [[scala.Double]]. */ - @deprecated("Use `scala.Double.MinValue` instead", "2.8.0") - val MIN_DOUBLE = -java.lang.Double.MAX_VALUE - - /** The smallest difference between two values of [[scala.Double]]. */ - @deprecated("Use `scala.Double.MinPositiveValue` instead", "2.8.0") - val EPS_DOUBLE = java.lang.Double.MIN_VALUE - - /** The greatest possible value for [[scala.Double]]. */ - @deprecated("Use `scala.Double.MaxValue` instead", "2.8.0") - val MAX_DOUBLE = java.lang.Double.MAX_VALUE - - /** A value of type [[scala.Double]] that represents no number. */ - @deprecated("Use `scala.Double.NaN` instead", "2.8.0") - val NaN_DOUBLE = java.lang.Double.NaN - - /** Negative infinity of type [[scala.Double]]. */ - @deprecated("Use `scala.Double.NegativeInfinity` instead", "2.8.0") - val NEG_INF_DOUBLE = java.lang.Double.NEGATIVE_INFINITY - - /** Positive infinity of type [[scala.Double]]. */ - @deprecated("Use `scala.Double.PositiveInfinity` instead", "2.8.0") - val POS_INF_DOUBLE = java.lang.Double.POSITIVE_INFINITY -} diff --git a/src/library/scala/MathCommon.scala b/src/library/scala/MathCommon.scala deleted file mode 100644 index b7b54d50fa..0000000000 --- a/src/library/scala/MathCommon.scala +++ /dev/null @@ -1,139 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - -package scala - -/** Common code between the deprecated `scala.Math` object and - * the `scala.math` package object. - */ -private[scala] class MathCommon { - /** The `double` value that is closer than any other to `e`, the base of - * the natural logarithms. - */ - val E = java.lang.Math.E - - /** The `double` value that is closer than any other to `pi`, the ratio of - * the circumference of a circle to its diameter. - */ - val Pi = java.lang.Math.PI - - /** Returns a `double` value with a positive sign, greater than or equal - * to `0.0` and less than `1.0`. - */ - def random: Double = java.lang.Math.random() - - def sin(x: Double): Double = java.lang.Math.sin(x) - def cos(x: Double): Double = java.lang.Math.cos(x) - def tan(x: Double): Double = java.lang.Math.tan(x) - def asin(x: Double): Double = java.lang.Math.asin(x) - def acos(x: Double): Double = java.lang.Math.acos(x) - def atan(x: Double): Double = java.lang.Math.atan(x) - - /** Converts an angle measured in degrees to an approximately equivalent - * angle measured in radians. - * - * @param x an angle, in degrees - * @return the measurement of the angle `x` in radians. - */ - def toRadians(x: Double): Double = java.lang.Math.toRadians(x) - - /** Converts an angle measured in radians to an approximately equivalent - * angle measured in degrees. - * - * @param x angle, in radians - * @return the measurement of the angle `x` in degrees. - */ - def toDegrees(x: Double): Double = java.lang.Math.toDegrees(x) - - /** Returns Euler's number `e` raised to the power of a `double` value. - * - * @param x the exponent to raise `e` to. - * @return the value `e^a^`, where `e` is the base of the natural - * logarithms. - */ - def exp(x: Double): Double = java.lang.Math.exp(x) - def log(x: Double): Double = java.lang.Math.log(x) - def sqrt(x: Double): Double = java.lang.Math.sqrt(x) - def IEEEremainder(x: Double, y: Double): Double = java.lang.Math.IEEEremainder(x, y) - - def ceil(x: Double): Double = java.lang.Math.ceil(x) - def floor(x: Double): Double = java.lang.Math.floor(x) - - /** Returns the `double` value that is closest in value to the - * argument and is equal to a mathematical integer. - * - * @param x a `double` value - * @return the closest floating-point value to a that is equal to a - * mathematical integer. - */ - def rint(x: Double): Double = java.lang.Math.rint(x) - - /** Converts rectangular coordinates `(x, y)` to polar `(r, theta)`. - * - * @param x the ordinate coordinate - * @param y the abscissa coordinate - * @return the ''theta'' component of the point `(r, theta)` in polar - * coordinates that corresponds to the point `(x, y)` in - * Cartesian coordinates. - */ - def atan2(y: Double, x: Double): Double = java.lang.Math.atan2(y, x) - - /** Returns the value of the first argument raised to the power of the - * second argument. - * - * @param x the base. - * @param y the exponent. - * @return the value `x^y^`. - */ - def pow(x: Double, y: Double): Double = java.lang.Math.pow(x, y) - - /** Returns the closest `long` to the argument. - * - * @param x a floating-point value to be rounded to a `long`. - * @return the value of the argument rounded to the nearest`long` value. - */ - def round(x: Float): Int = java.lang.Math.round(x) - def round(x: Double): Long = java.lang.Math.round(x) - def abs(x: Int): Int = java.lang.Math.abs(x) - def abs(x: Long): Long = java.lang.Math.abs(x) - def abs(x: Float): Float = java.lang.Math.abs(x) - def abs(x: Double): Double = java.lang.Math.abs(x) - - def max(x: Int, y: Int): Int = java.lang.Math.max(x, y) - def max(x: Long, y: Long): Long = java.lang.Math.max(x, y) - def max(x: Float, y: Float): Float = java.lang.Math.max(x, y) - def max(x: Double, y: Double): Double = java.lang.Math.max(x, y) - - def min(x: Int, y: Int): Int = java.lang.Math.min(x, y) - def min(x: Long, y: Long): Long = java.lang.Math.min(x, y) - def min(x: Float, y: Float): Float = java.lang.Math.min(x, y) - def min(x: Double, y: Double): Double = java.lang.Math.min(x, y) - - def signum(x: Double): Double = - if (x == 0d) 0d - else if (x < 0) -1.0 - else if (x > 0) 1.0 - else x // NaN - - def signum(x: Float): Float = - if (x == 0f) 0f - else if (x < 0) -1.0f - else if (x > 0) 1.0f - else x // NaN - - def signum(x: Long): Long = - if (x == 0l) 0l - else if (x < 0) -1l - else 1l - - def signum(x: Int): Int = - if (x == 0) 0 - else if (x < 0) -1 - else 1 -} diff --git a/src/library/scala/NotDefinedError.scala b/src/library/scala/NotDefinedError.scala deleted file mode 100644 index 1fd0e7ec49..0000000000 --- a/src/library/scala/NotDefinedError.scala +++ /dev/null @@ -1,17 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala - -/** - * @since 2.0 - */ -@deprecated("Use a custom Error class instead", "2.8.0") -final class NotDefinedError(msg: String) extends Error("not defined: " + msg) diff --git a/src/library/scala/Product.scala b/src/library/scala/Product.scala index cb316f2da3..53a838ee9d 100644 --- a/src/library/scala/Product.scala +++ b/src/library/scala/Product.scala @@ -42,9 +42,6 @@ trait Product extends Equals { def next() = { val result = productElement(c); c += 1; result } } - @deprecated("use productIterator instead", "2.8.0") - def productElements: Iterator[Any] = productIterator - /** A string used in the `toString` methods of derived classes. * Implementations may override this method to prepend a string prefix * to the result of `toString` methods. diff --git a/src/library/scala/UninitializedFieldError.scala b/src/library/scala/UninitializedFieldError.scala index 476485d798..a6e510a849 100644 --- a/src/library/scala/UninitializedFieldError.scala +++ b/src/library/scala/UninitializedFieldError.scala @@ -13,11 +13,8 @@ package scala /** This class implements errors which are thrown whenever a * field is used before it has been initialized. * - * Such runtime checks are not emitted by default. See the - * compiler documentation for knowing how to turn them on. - * - * Note: This check requires the initialization order - * first implemented in scala 2.8. + * Such runtime checks are not emitted by default. + * They can be enabled by the `-Xcheckinit` compiler option. * * @since 2.7 */ diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala index 0381da0841..0717861c26 100644 --- a/src/library/scala/collection/Iterable.scala +++ b/src/library/scala/collection/Iterable.scala @@ -48,15 +48,4 @@ object Iterable extends TraversableFactory[Iterable] { implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, Iterable[A]] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]] def newBuilder[A]: Builder[A, Iterable[A]] = immutable.Iterable.newBuilder[A] - - /** The minimum element of a non-empty sequence of ordered elements */ - @deprecated("use <seq>.min instead, where <seq> is the sequence for which you want to compute the minimum", "2.8.0") - def min[A](seq: Iterable[A])(implicit ord: Ordering[A]): A = seq.min - - /** The maximum element of a non-empty sequence of ordered elements */ - @deprecated("use <seq>.max instead, where <seq> is the sequence for which you want to compute the maximum", "2.8.0") - def max[A](seq: Iterable[A])(implicit ord: Ordering[A]): A = seq.max - - @deprecated("use View instead", "2.8.0") - type Projection[A] = IterableView[A, Coll] } diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala index 3e63800f2d..e5aa381c9f 100644 --- a/src/library/scala/collection/IterableLike.scala +++ b/src/library/scala/collection/IterableLike.scala @@ -298,23 +298,4 @@ self => } override /*TraversableLike*/ def view(from: Int, until: Int) = view.slice(from, until) - - @deprecated("use `iterator` instead", "2.8.0") - def elements = iterator - - @deprecated("use `head` instead", "2.8.0") - def first: A = head - - /** `None` if iterable is empty. - */ - @deprecated("use `headOption` instead", "2.8.0") - def firstOption: Option[A] = headOption - - /** - * returns a projection that can be used to call non-strict `filter`, - * `map`, and `flatMap` methods that build projections - * of the collection. - */ - @deprecated("use `view` instead", "2.8.0") - def projection = view } diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala index 705ef4e0ed..fabb106f3e 100644 --- a/src/library/scala/collection/Iterator.scala +++ b/src/library/scala/collection/Iterator.scala @@ -149,86 +149,6 @@ object Iterator { def hasNext = true def next = elem } - - @deprecated("use `xs.iterator` or `Iterator(xs)` instead", "2.8.0") - def fromValues[a](xs: a*) = xs.iterator - - /** @param xs the array of elements - * @see also: IndexedSeq.iterator and slice - */ - @deprecated("use `xs.iterator` instead", "2.8.0") - def fromArray[a](xs: Array[a]): Iterator[a] = - fromArray(xs, 0, xs.length) - - /** - * @param xs the array of elements - * @param start the start index - * @param length the length - * @see also: IndexedSeq.iterator and slice - */ - @deprecated("use `xs.slice(start, start + length).iterator` instead", "2.8.0") - def fromArray[a](xs: Array[a], start: Int, length: Int): Iterator[a] = - xs.slice(start, start + length).iterator - - /** - * @param n the product arity - * @return the iterator on `Product<n>`. - */ - @deprecated("use `product.productIterator instead`", "2.8.0") - def fromProduct(n: Product): Iterator[Any] = new Iterator[Any] { - private var c: Int = 0 - private val cmax = n.productArity - def hasNext = c < cmax - def next() = { val a = n productElement c; c += 1; a } - } - - /** Create an iterator with elements `e<sub>n+1</sub> = step(e<sub>n</sub>)` where `e<sub>0</sub> = start` - * and elements are in the range between `start` (inclusive) and `end` (exclusive). - * - * @param start the start value of the iterator - * @param end the end value of the iterator - * @param step the increment function of the iterator, must be monotonically increasing or decreasing - * @return the iterator with values in range `[start;end)`. - */ - @deprecated("use `Iterator.iterate(start, end - start)(step)` instead", "2.8.0") - def range(start: Int, end: Int, step: Int => Int) = new Iterator[Int] { - private val up = step(start) > start - private val down = step(start) < start - private var i = start - def hasNext: Boolean = (!up || i < end) && (!down || i > end) - def next(): Int = - if (hasNext) { val j = i; i = step(i); j } - else empty.next() - } - - /** Create an iterator with elements `e<sub>n+1</sub> = step(e<sub>n</sub>)` where `e<sub>0</sub> = start`. - * - * @param start the start value of the iterator - * @param step the increment function of the iterator - * @return the iterator starting at value `start`. - */ - @deprecated("use `iterate(start)(step)` instead", "2.8.0") - def from(start: Int, step: Int => Int): Iterator[Int] = new Iterator[Int] { - private var i = start - override def hasNext: Boolean = true - def next(): Int = { val j = i; i = step(i); j } - } - - /** Create an iterator that is the concatenation of all iterators returned by a given iterator of iterators. - * - * @param its The iterator which returns on each call to next - * a new iterator whose elements are to be concatenated to the result. - */ - @deprecated("use `its.flatten` instead", "2.8.0") - def flatten[T](its: Iterator[Iterator[T]]): Iterator[T] = new Iterator[T] { - private var cur = its.next - def hasNext: Boolean = { - while (!cur.hasNext && its.hasNext) cur = its.next - cur.hasNext - } - def next(): T = - (if (hasNext) cur else empty).next() - } } import Iterator.empty @@ -1030,52 +950,4 @@ trait Iterator[+A] extends TraversableOnce[A] { * whether or not the iterator is empty. */ override def toString = (if (hasNext) "non-empty" else "empty")+" iterator" - - /** Returns a new iterator that first yields the elements of this - * iterator followed by the elements provided by iterator `that`. - */ - @deprecated("use `++`", "2.3.2") - def append[B >: A](that: Iterator[B]) = self ++ that - - /** Returns index of the first element satisfying a predicate, or -1. */ - @deprecated("use `indexWhere` instead", "2.8.0") - def findIndexOf(p: A => Boolean): Int = indexWhere(p) - - /** Returns a counted iterator from this iterator. - */ - @deprecated("use `zipWithIndex` in `Iterator`", "2.8.0") - def counted = new CountedIterator[A] { - private var cnt = 0 - def count = cnt - def hasNext: Boolean = self.hasNext - def next(): A = { cnt += 1; self.next } - } - - /** Fills the given array `xs` with the elements of - * this sequence starting at position `start`. Like `copyToArray`, - * but designed to accomodate IO stream operations. - * - * '''Note:''' the array must be large enough to hold `sz` elements. - * @param xs the array to fill. - * @param start the starting index. - * @param sz the maximum number of elements to be read. - */ - @deprecated("use `copyToArray` instead", "2.8.0") - def readInto[B >: A](xs: Array[B], start: Int, sz: Int) { - var i = start - while (hasNext && i - start < sz) { - xs(i) = next - i += 1 - } - } - - @deprecated("use `copyToArray` instead", "2.8.0") - def readInto[B >: A](xs: Array[B], start: Int) { - readInto(xs, start, xs.length - start) - } - - @deprecated("use copyToArray instead", "2.8.0") - def readInto[B >: A](xs: Array[B]) { - readInto(xs, 0, xs.length) - } } diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala index 39b86ad85d..ea3c911169 100644 --- a/src/library/scala/collection/JavaConversions.scala +++ b/src/library/scala/collection/JavaConversions.scala @@ -73,9 +73,6 @@ object JavaConversions { case _ => IteratorWrapper(i) } - @deprecated("use asJavaIterator instead", "2.8.1") - def asIterator[A](i : Iterator[A]): ju.Iterator[A] = asJavaIterator[A](i) - /** * Implicitly converts a Scala Iterator to a Java Enumeration. * The returned Java Enumeration is backed by the provided Scala @@ -94,9 +91,6 @@ object JavaConversions { case _ => IteratorWrapper(i) } - @deprecated("use asJavaEnmeration instead", "2.8.1") - def asEnumeration[A](i : Iterator[A]): ju.Enumeration[A] = asJavaEnumeration[A](i) - /** * Implicitly converts a Scala Iterable to a Java Iterable. * The returned Java Iterable is backed by the provided Scala @@ -115,9 +109,6 @@ object JavaConversions { case _ => IterableWrapper(i) } - @deprecated("use asJavaIterable instead", "2.8.1") - def asIterable[A](i : Iterable[A]): jl.Iterable[A] = asJavaIterable[A](i) - /** * Implicitly converts a Scala Iterable to an immutable Java * Collection. @@ -134,9 +125,6 @@ object JavaConversions { case _ => new IterableWrapper(i) } - @deprecated("use asJavaCollection instead", "2.8.1") - def asCollection[A](i : Iterable[A]): ju.Collection[A] = asJavaCollection[A](i) - /** * Implicitly converts a Scala mutable Buffer to a Java List. * The returned Java List is backed by the provided Scala @@ -156,8 +144,6 @@ object JavaConversions { } @deprecated("use bufferAsJavaList instead", "2.9.0") def asJavaList[A](b : mutable.Buffer[A]): ju.List[A] = bufferAsJavaList[A](b) - @deprecated("use bufferAsJavaList instead", "2.8.1") - def asList[A](b : mutable.Buffer[A]): ju.List[A] = bufferAsJavaList[A](b) /** * Implicitly converts a Scala mutable Seq to a Java List. @@ -178,8 +164,6 @@ object JavaConversions { } @deprecated("use mutableSeqAsJavaList instead", "2.9.0") def asJavaList[A](b : mutable.Seq[A]): ju.List[A] = mutableSeqAsJavaList[A](b) - @deprecated("use mutableSeqAsJavaList instead", "2.8.1") - def asList[A](b : mutable.Seq[A]): ju.List[A] = mutableSeqAsJavaList[A](b) /** * Implicitly converts a Scala Seq to a Java List. @@ -201,8 +185,6 @@ object JavaConversions { @deprecated("use seqAsJavaList instead", "2.9.0") def asJavaList[A](b : Seq[A]): ju.List[A] = seqAsJavaList[A](b) - @deprecated("use seqAsJavaList instead", "2.8.1") - def asList[A](b : Seq[A]): ju.List[A] = seqAsJavaList[A](b) /** * Implicitly converts a Scala mutable Set to a Java Set. @@ -224,8 +206,6 @@ object JavaConversions { @deprecated("use mutableSetAsJavaSet instead", "2.9.0") def asJavaSet[A](s : mutable.Set[A]): ju.Set[A] = mutableSetAsJavaSet[A](s) - @deprecated("use mutableSetAsJavaSet instead", "2.8.1") - def asSet[A](s : mutable.Set[A]): ju.Set[A] = mutableSetAsJavaSet[A](s) /** * Implicitly converts a Scala Set to a Java Set. @@ -247,8 +227,6 @@ object JavaConversions { @deprecated("use setAsJavaSet instead", "2.9.0") def asJavaSet[A](s: Set[A]): ju.Set[A] = setAsJavaSet[A](s) - @deprecated("use setAsJavaSet instead", "2.8.1") - def asSet[A](s : Set[A]): ju.Set[A] = setAsJavaSet[A](s) /** * Implicitly converts a Scala mutable Map to a Java Map. @@ -271,8 +249,6 @@ object JavaConversions { @deprecated("use mutableMapAsJavaMap instead", "2.9.0") def asJavaMap[A, B](m : mutable.Map[A, B]): ju.Map[A, B] = mutableMapAsJavaMap[A, B](m) - @deprecated("use mutableMapAsJavaMap instead", "2.8.1") - def asMap[A, B](m : mutable.Map[A, B]): ju.Map[A, B] = mutableMapAsJavaMap[A, B](m) /** * Implicitly converts a Scala mutable `Map` to a Java `Dictionary`. @@ -294,9 +270,6 @@ object JavaConversions { case _ => new DictionaryWrapper(m) } - @deprecated("use asJavaDictionary instead", "2.8.1") - def asDictionary[A, B](m : mutable.Map[A, B]): ju.Dictionary[A, B] = asJavaDictionary[A, B](m) - /** * Implicitly converts a Scala `Map` to a Java `Map`. * @@ -319,8 +292,6 @@ object JavaConversions { @deprecated("use mapAsJavaMap instead", "2.9.0") def asJavaMap[A, B](m : Map[A, B]): ju.Map[A, B] = mapAsJavaMap[A, B](m) - @deprecated("use mapAsJavaMap instead", "2.8.1") - def asMap[A, B](m : Map[A, B]): ju.Map[A, B] = mapAsJavaMap[A, B](m) /** * Implicitly converts a Scala mutable `ConcurrentMap` to a Java @@ -342,9 +313,6 @@ object JavaConversions { case _ => new ConcurrentMapWrapper(m) } - @deprecated("use asJavaConcurrentMap instead", "2.8.1") - def asConcurrentMap[A, B](m: mutable.ConcurrentMap[A, B]): juc.ConcurrentMap[A, B] = asJavaConcurrentMap[A, B](m) - // Java => Scala /** @@ -366,9 +334,6 @@ object JavaConversions { case _ => JIteratorWrapper(i) } - @deprecated("use asScalaIterator instead", "2.8.1") - def asIterator[A](i : ju.Iterator[A]): Iterator[A] = asScalaIterator[A](i) - /** * Implicitly converts a Java Enumeration to a Scala Iterator. * The returned Scala Iterator is backed by the provided Java @@ -387,9 +352,6 @@ object JavaConversions { case _ => JEnumerationWrapper(i) } - @deprecated("use enumerationAsScalaIterator instead", "2.8.1") - def asIterator[A](i : ju.Enumeration[A]): Iterator[A] = enumerationAsScalaIterator[A](i) - /** * Implicitly converts a Java `Iterable` to a Scala `Iterable`. * @@ -411,8 +373,6 @@ object JavaConversions { @deprecated("use iterableAsScalaIterable instead", "2.9.0") def asScalaIterable[A](i : jl.Iterable[A]): Iterable[A] = iterableAsScalaIterable[A](i) - @deprecated("use iterableAsScalaIterable instead", "2.8.1") - def asIterable[A](i : jl.Iterable[A]): Iterable[A] = iterableAsScalaIterable[A](i) /** * Implicitly converts a Java `Collection` to an Scala `Iterable`. @@ -430,8 +390,6 @@ object JavaConversions { } @deprecated("use collectionAsScalaIterable instead", "2.9.0") def asScalaIterable[A](i : ju.Collection[A]): Iterable[A] = collectionAsScalaIterable[A](i) - @deprecated("use collectionAsScalaIterable instead", "2.8.1") - def asIterable[A](i : ju.Collection[A]): Iterable[A] = collectionAsScalaIterable[A](i) /** * Implicitly converts a Java `List` to a Scala mutable `Buffer`. @@ -452,9 +410,6 @@ object JavaConversions { case _ =>new JListWrapper(l) } - @deprecated("use asScalaBuffer instead", "2.8.1") - def asBuffer[A](l : ju.List[A]): mutable.Buffer[A] = asScalaBuffer[A](l) - /** * Implicitly converts a Java Set to a Scala mutable Set. * The returned Scala Set is backed by the provided Java @@ -473,9 +428,6 @@ object JavaConversions { case _ =>new JSetWrapper(s) } - @deprecated("use asScalaSet instead", "2.8.1") - def asSet[A](s : ju.Set[A]): mutable.Set[A] = asScalaSet[A](s) - /** * Implicitly converts a Java `Map` to a Scala mutable `Map`. * @@ -498,8 +450,6 @@ object JavaConversions { @deprecated("use mapAsScalaMap instead", "2.9.0") def asScalaMap[A, B](m : ju.Map[A, B]): mutable.Map[A, B] = mapAsScalaMap[A, B](m) - @deprecated("use mapAsScalaMap instead", "2.8.1") - def asMap[A, B](m : ju.Map[A, B]): mutable.Map[A, B] = mapAsScalaMap[A, B](m) /** * Implicitly converts a Java ConcurrentMap to a Scala mutable ConcurrentMap. @@ -519,9 +469,6 @@ object JavaConversions { case _ => new JConcurrentMapWrapper(m) } - @deprecated("use asScalaConcurrentMap instead", "2.8.1") - def asConcurrentMap[A, B](m: juc.ConcurrentMap[A, B]): mutable.ConcurrentMap[A, B] = asScalaConcurrentMap[A, B](m) - /** * Implicitly converts a Java `Dictionary` to a Scala mutable * `Map[String, String]`. @@ -538,9 +485,6 @@ object JavaConversions { case _ => new JDictionaryWrapper(p) } - @deprecated("use dictionaryAsScalaMap instead", "2.8.1") - def asMap[A, B](p: ju.Dictionary[A, B]): mutable.Map[A, B] = dictionaryAsScalaMap[A, B](p) - /** * Implicitly converts a Java `Properties` to a Scala `mutable Map[String, String]`. * @@ -557,8 +501,6 @@ object JavaConversions { @deprecated("use propertiesAsScalaMap instead", "2.9.0") def asScalaMap(p: ju.Properties): mutable.Map[String, String] = propertiesAsScalaMap(p) - @deprecated("use propertiesAsScalaMap instead", "2.8.1") - def asMap(p: ju.Properties): mutable.Map[String, String] = propertiesAsScalaMap(p) // Private implementations (shared by JavaConverters) ... diff --git a/src/library/scala/collection/MapLike.scala b/src/library/scala/collection/MapLike.scala index 4ffcc111cc..5b4ac20329 100644 --- a/src/library/scala/collection/MapLike.scala +++ b/src/library/scala/collection/MapLike.scala @@ -246,9 +246,6 @@ self => def get(key: A) = self.get(key).map(f) } - @deprecated("use `mapValues` instead", "2.8.0") - def mapElements[C](f: B => C) = mapValues(f) - // The following 5 operations (updated, two times +, two times ++) should really be // generic, returning This[B]. We need better covariance support to express that though. // So right now we do the brute force approach of code duplication. diff --git a/src/library/scala/collection/Seq.scala b/src/library/scala/collection/Seq.scala index 2fbbaee355..04d513b7e4 100644 --- a/src/library/scala/collection/Seq.scala +++ b/src/library/scala/collection/Seq.scala @@ -39,11 +39,5 @@ object Seq extends SeqFactory[Seq] { implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, Seq[A]] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]] def newBuilder[A]: Builder[A, Seq[A]] = immutable.Seq.newBuilder[A] - - @deprecated("use View instead", "2.8.0") - type Projection[A] = SeqView[A, Coll] - - @deprecated("use Seq(value) instead", "2.8.0") - def singleton[A](value: A) = Seq(value) } diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala index 684aaac214..3d7b0064d9 100644 --- a/src/library/scala/collection/SeqLike.scala +++ b/src/library/scala/collection/SeqLike.scala @@ -118,11 +118,6 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] -1 } - /** Returns index of the first element satisfying a predicate, or `-1`. - */ - @deprecated("Use indexWhere(p) instead.", "2.8.0") - def findIndexOf(p: A => Boolean): Int = indexWhere(p) - def lastIndexWhere(p: A => Boolean, end: Int): Int = { var i = length - 1 val it = reverseIterator @@ -290,9 +285,6 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] */ def reverseIterator: Iterator[A] = toCollection(reverse).iterator - @deprecated("use `reverseIterator` instead", "2.8.0") - def reversedElements = reverseIterator - def startsWith[B](that: GenSeq[B], offset: Int): Boolean = { val i = this.iterator drop offset val j = that.iterator @@ -678,31 +670,6 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] /* Need to override string, so that it's not the Function1's string that gets mixed in. */ override def toString = super[IterableLike].toString - - /** Returns index of the last element satisfying a predicate, or -1. - */ - @deprecated("use `lastIndexWhere` instead", "2.8.0") - def findLastIndexOf(p: A => Boolean): Int = lastIndexWhere(p) - - /** Tests whether every element of this $coll relates to the - * corresponding element of another sequence by satisfying a test predicate. - * - * @param that the other sequence - * @param p the test predicate, which relates elements from both sequences - * @tparam B the type of the elements of `that` - * @return `true` if both sequences have the same length and - * `p(x, y)` is `true` for all corresponding elements `x` of this $coll - * and `y` of `that`, otherwise `false`. - */ - @deprecated("use `corresponds` instead", "2.8.0") - def equalsWith[B](that: Seq[B])(f: (A,B) => Boolean): Boolean = corresponds(that)(f) - - /** - * returns a projection that can be used to call non-strict `filter`, - * `map`, and `flatMap` methods that build projections of the collection. - */ - @deprecated("use `view` instead", "2.8.0") - override def projection = view } /** The companion object for trait `SeqLike`. diff --git a/src/library/scala/collection/SeqProxyLike.scala b/src/library/scala/collection/SeqProxyLike.scala index 565bd9ff5e..ce32ba97c2 100644 --- a/src/library/scala/collection/SeqProxyLike.scala +++ b/src/library/scala/collection/SeqProxyLike.scala @@ -33,7 +33,6 @@ trait SeqProxyLike[+A, +Repr <: SeqLike[A, Repr] with Seq[A]] extends SeqLike[A, override def prefixLength(p: A => Boolean) = self.prefixLength(p) override def indexWhere(p: A => Boolean): Int = self.indexWhere(p) override def indexWhere(p: A => Boolean, from: Int): Int = self.indexWhere(p, from) - override def findIndexOf(p: A => Boolean): Int = self.indexWhere(p) override def indexOf[B >: A](elem: B): Int = self.indexOf(elem) override def indexOf[B >: A](elem: B, from: Int): Int = self.indexOf(elem, from) override def lastIndexOf[B >: A](elem: B): Int = self.lastIndexOf(elem) diff --git a/src/library/scala/collection/SetLike.scala b/src/library/scala/collection/SetLike.scala index 395e253430..fecbaa61f2 100644 --- a/src/library/scala/collection/SetLike.scala +++ b/src/library/scala/collection/SetLike.scala @@ -144,15 +144,6 @@ self => */ override def isEmpty: Boolean = size == 0 - /** This method is an alias for `intersect`. - * It computes an intersection with set `that`. - * It removes all the elements that are not present in `that`. - * - * @param that the set to intersect with - */ - @deprecated("use & instead", "2.8.0") - def ** (that: Set[A]): This = &(that) - /** Computes the union between of set and another set. * * @param that the set to form the union with. diff --git a/src/library/scala/collection/TraversableView.scala b/src/library/scala/collection/TraversableView.scala index 99d3551275..67886eb3b4 100644 --- a/src/library/scala/collection/TraversableView.scala +++ b/src/library/scala/collection/TraversableView.scala @@ -24,8 +24,6 @@ object TraversableView { class NoBuilder[A] extends Builder[A, Nothing] { def +=(elem: A): this.type = this def iterator: Iterator[A] = Iterator.empty - @deprecated("use `iterator` instead", "2.8.0") - def elements = iterator def result() = throw new UnsupportedOperationException("TraversableView.Builder.result") def clear() {} } diff --git a/src/library/scala/collection/generic/Addable.scala b/src/library/scala/collection/generic/Addable.scala deleted file mode 100644 index e2a34c1ed2..0000000000 --- a/src/library/scala/collection/generic/Addable.scala +++ /dev/null @@ -1,61 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - -package scala.collection -package generic - -import annotation.bridge - -/** This trait represents collection-like objects that can be added to - * using a '+' operator. It defines variants of `+` and `++` - * as convenience methods in terms of single-element addition `+`. - * @tparam A the type of the elements of the $coll - * @tparam Repr the type of the $coll itself - * @author Martin Odersky - * @version 2.8 - * @since 2.8 - * @define coll collection - * @define Coll Addable - */ -@deprecated("Will be removed after scala 2.9", "2.8.0") -trait Addable[A, +Repr <: Addable[A, Repr]] { self => - - /** The representation object of type `Repr` which contains the collection's elements - */ - protected def repr: Repr - - /** Creates a new $coll with an additional element, unless the element is already present. - * @param elem the element to add - * @return a fresh collection with `elem` added. - */ - def +(elem: A): Repr - - /** Creates a new $coll with additional elements. - * - * This method takes two or more elements to be added. Another overloaded - * variant of this method handles the case where a single element is - * added. - * @param elem1 the first element to add. - * @param elem2 the second element to add. - * @param elems the remaining elements to add. - * @return a new $coll with the given elements added. - */ - def + (elem1: A, elem2: A, elems: A*): Repr = - this + elem1 + elem2 ++ elems - - /** Creates a new $coll by adding all elements contained in another collection to this $coll. - * - * @param elems the collection containing the added elements. - * @return a new $coll with the given elements added. - */ - def ++ (xs: GenTraversableOnce[A]): Repr = (repr /: xs.seq) (_ + _) - - @bridge - def ++ (xs: TraversableOnce[A]): Repr = ++ (xs: GenTraversableOnce[A]) -} diff --git a/src/library/scala/collection/generic/SeqForwarder.scala b/src/library/scala/collection/generic/SeqForwarder.scala index eb8e0b3ee9..10e8c37cbf 100644 --- a/src/library/scala/collection/generic/SeqForwarder.scala +++ b/src/library/scala/collection/generic/SeqForwarder.scala @@ -35,7 +35,6 @@ trait SeqForwarder[+A] extends Seq[A] with IterableForwarder[A] { override def prefixLength(p: A => Boolean) = underlying prefixLength p override def indexWhere(p: A => Boolean): Int = underlying indexWhere p override def indexWhere(p: A => Boolean, from: Int): Int = underlying.indexWhere(p, from) - override def findIndexOf(p: A => Boolean): Int = underlying indexWhere p override def indexOf[B >: A](elem: B): Int = underlying indexOf elem override def indexOf[B >: A](elem: B, from: Int): Int = underlying.indexOf(elem, from) override def lastIndexOf[B >: A](elem: B): Int = underlying lastIndexOf elem diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala index 8f7d92f9e5..5791e9788d 100644 --- a/src/library/scala/collection/immutable/List.scala +++ b/src/library/scala/collection/immutable/List.scala @@ -245,114 +245,6 @@ sealed abstract class List[+A] extends LinearSeq[A] override def toStream : Stream[A] = if (isEmpty) Stream.Empty else new Stream.Cons(head, tail.toStream) - - /** Like `span` but with the predicate inverted. - */ - @deprecated("use `span { x => !p(x) }` instead", "2.8.0") - def break(p: A => Boolean): (List[A], List[A]) = span { x => !p(x) } - - @deprecated("use `filterNot` instead", "2.8.0") - def remove(p: A => Boolean): List[A] = filterNot(p) - - /** Computes the difference between this list and the given list `that`. - * - * @param that the list of elements to remove from this list. - * @return this list without the elements of the given list `that`. - */ - @deprecated("use `list1 filterNot (list2 contains)` instead", "2.8.0") - def -- [B >: A](that: List[B]): List[B] = { - val b = new ListBuffer[B] - var these = this - while (!these.isEmpty) { - if (!that.contains(these.head)) b += these.head - these = these.tail - } - b.toList - } - - /** Computes the difference between this list and the given object `x`. - * - * @param x the object to remove from this list. - * @return this list without occurrences of the given object - * `x`. - */ - @deprecated("use `filterNot (_ == x)` instead", "2.8.0") - def - [B >: A](x: B): List[B] = { - val b = new ListBuffer[B] - var these = this - while (!these.isEmpty) { - if (these.head != x) b += these.head - these = these.tail - } - b.toList - } - - @deprecated("use `distinct` instead", "2.8.0") - def removeDuplicates: List[A] = distinct - - @deprecated("use `sortWith` instead", "2.8.0") - def sort(lt : (A,A) => Boolean): List[A] = { - /** Merge two already-sorted lists */ - def merge(l1: List[A], l2: List[A]): List[A] = { - val res = new ListBuffer[A] - var left1 = l1 - var left2 = l2 - - while (!left1.isEmpty && !left2.isEmpty) { - if(lt(left1.head, left2.head)) { - res += left1.head - left1 = left1.tail - } else { - res += left2.head - left2 = left2.tail - } - } - - res ++= left1 - res ++= left2 - - res.toList - } - - /** Split a list `lst` into two lists of about the same size */ - def split(lst: List[A]) = { - val res1 = new ListBuffer[A] - val res2 = new ListBuffer[A] - var left = lst - - while (!left.isEmpty) { - res1 += left.head - left = left.tail - if (!left.isEmpty) { - res2 += left.head - left = left.tail - } - } - - (res1.toList, res2.toList) - } - - /** Merge-sort the specified list */ - def ms(lst: List[A]): List[A] = - lst match { - case Nil => lst - case x :: Nil => lst - case x :: y :: Nil => - if (lt(x,y)) - lst - else - y :: x :: Nil - - case lst => - val (l1, l2) = split(lst) - val l1s = ms(l1) - val l2s = ms(l2) - merge(l1s, l2s) - } - - ms(this) - } - } /** The empty list. @@ -419,8 +311,6 @@ final case class ::[B](private var hd: B, private[scala] var tl: List[B]) extend */ object List extends SeqFactory[List] { - import scala.collection.{Iterable, Seq, IndexedSeq} - /** $genericCanBuildFromInfo */ implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, List[A]] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]] @@ -430,337 +320,6 @@ object List extends SeqFactory[List] { override def empty[A]: List[A] = Nil override def apply[A](xs: A*): List[A] = xs.toList - - /** Create a sorted list with element values `v,,>n+1,, = step(v,,n,,)` - * where `v,,0,, = start` and elements are in the range between `start` - * (inclusive) and `end` (exclusive). - * - * @param start the start value of the list - * @param end the end value of the list - * @param step the increment function of the list, which given `v,,n,,`, - * computes `v,,n+1,,`. Must be monotonically increasing - * or decreasing. - * @return the sorted list of all integers in range `[start;end)`. - */ - @deprecated("use `iterate` instead", "2.8.0") - def range(start: Int, end: Int, step: Int => Int): List[Int] = { - val up = step(start) > start - val down = step(start) < start - val b = new ListBuffer[Int] - var i = start - while ((!up || i < end) && (!down || i > end)) { - b += i - val next = step(i) - if (i == next) - throw new IllegalArgumentException("the step function did not make any progress on "+ i) - i = next - } - b.toList - } - - /** Create a list containing several copies of an element. - * - * @param n the length of the resulting list - * @param elem the element composing the resulting list - * @return a list composed of `n` elements all equal to `elem` - */ - @deprecated("use `fill` instead", "2.8.0") - def make[A](n: Int, elem: A): List[A] = { - val b = new ListBuffer[A] - var i = 0 - while (i < n) { - b += elem - i += 1 - } - b.toList - } - - /** Concatenate all the elements of a given list of lists. - * - * @param xss the list of lists that are to be concatenated - * @return the concatenation of all the lists - */ - @deprecated("use `xss.flatten` instead of `List.flatten(xss)`", "2.8.0") - def flatten[A](xss: List[List[A]]): List[A] = { - val b = new ListBuffer[A] - for (xs <- xss) { - var xc = xs - while (!xc.isEmpty) { - b += xc.head - xc = xc.tail - } - } - b.toList - } - - /** Transforms a list of pairs into a pair of lists. - * - * @param xs the list of pairs to unzip - * @return a pair of lists. - */ - @deprecated("use `xs.unzip` instead of `List.unzip(xs)`", "2.8.0") - def unzip[A,B](xs: List[(A,B)]): (List[A], List[B]) = { - val b1 = new ListBuffer[A] - val b2 = new ListBuffer[B] - var xc = xs - while (!xc.isEmpty) { - b1 += xc.head._1 - b2 += xc.head._2 - xc = xc.tail - } - (b1.toList, b2.toList) - } - - /** Transforms an iterable of pairs into a pair of lists. - * - * @param xs the iterable of pairs to unzip - * @return a pair of lists. - */ - @deprecated("use `xs.unzip` instead of `List.unzip(xs)`", "2.8.0") - def unzip[A,B](xs: Iterable[(A,B)]): (List[A], List[B]) = - xs.foldRight[(List[A], List[B])]((Nil, Nil)) { - case ((x, y), (xs, ys)) => (x :: xs, y :: ys) - } - - /** - * Returns the `Left` values in the given `Iterable` of `Either`s. - */ - @deprecated("use `xs collect { case Left(x: A) => x }` instead of `List.lefts(xs)`", "2.8.0") - def lefts[A, B](es: Iterable[Either[A, B]]) = - es.foldRight[List[A]](Nil)((e, as) => e match { - case Left(a) => a :: as - case Right(_) => as - }) - - /** - * Returns the `Right` values in the given `Iterable` of `Either`s. - */ - @deprecated("use `xs collect { case Right(x: B) => x }` instead of `List.rights(xs)`", "2.8.0") - def rights[A, B](es: Iterable[Either[A, B]]) = - es.foldRight[List[B]](Nil)((e, bs) => e match { - case Left(_) => bs - case Right(b) => b :: bs - }) - - /** Transforms an Iterable of Eithers into a pair of lists. - * - * @param xs the iterable of Eithers to separate - * @return a pair of lists. - */ - @deprecated("use `(for (Left(x) <- es) yield x, for (Right(x) <- es) yield x)` instead", "2.8.0") - def separate[A,B](es: Iterable[Either[A, B]]): (List[A], List[B]) = - es.foldRight[(List[A], List[B])]((Nil, Nil)) { - case (Left(a), (lefts, rights)) => (a :: lefts, rights) - case (Right(b), (lefts, rights)) => (lefts, b :: rights) - } - - /** Converts an iterator to a list. - * - * @param it the iterator to convert - * @return a list that contains the elements returned by successive - * calls to `it.next` - */ - @deprecated("use `it.toList` instead of `List.toList(it)`", "2.8.0") - def fromIterator[A](it: Iterator[A]): List[A] = it.toList - - /** Converts an array into a list. - * - * @param arr the array to convert - * @return a list that contains the same elements than `arr` - * in the same order - */ - @deprecated("use `array.toList` instead of `List.fromArray(array)`", "2.8.0") - def fromArray[A](arr: Array[A]): List[A] = fromArray(arr, 0, arr.length) - - /** Converts a range of an array into a list. - * - * @param arr the array to convert - * @param start the first index to consider - * @param len the length of the range to convert - * @return a list that contains the same elements than `arr` - * in the same order - */ - @deprecated("use `array.view(start, end).toList` instead of `List.fromArray(array, start, end)`", "2.8.0") - def fromArray[A](arr: Array[A], start: Int, len: Int): List[A] = { - var res: List[A] = Nil - var i = start + len - while (i > start) { - i -= 1 - res = arr(i) :: res - } - res - } - - /** Parses a string which contains substrings separated by a - * separator character and returns a list of all substrings. - * - * @param str the string to parse - * @param separator the separator character - * @return the list of substrings - */ - @deprecated("use `str.split(separator).toList` instead of `List.fromString(str, separator)`", "2.8.0") - def fromString(str: String, separator: Char): List[String] = { - var words: List[String] = Nil - var pos = str.length() - while (pos > 0) { - val pos1 = str.lastIndexOf(separator, pos - 1) - if (pos1 + 1 < pos) - words = str.substring(pos1 + 1, pos) :: words - pos = pos1 - } - words - } - - /** Returns the given list of characters as a string. - * - * @param xs the list to convert. - * @return the list in form of a string. - */ - @deprecated("use `xs.mkString` instead of `List.toString(xs)`", "2.8.0") - def toString(xs: List[Char]): String = { - val sb = new StringBuilder() - var xc = xs - while (!xc.isEmpty) { - sb.append(xc.head) - xc = xc.tail - } - sb.toString() - } - - /** Like xs map f, but returns `xs` unchanged if function - * `f` maps all elements to themselves. - */ - @deprecated("use `xs.mapConserve(f)` instead of `List.mapConserve(xs, f)`", "2.8.0") - def mapConserve[A <: AnyRef](xs: List[A])(f: A => A): List[A] = { - def loop(ys: List[A]): List[A] = - if (ys.isEmpty) xs - else { - val head0 = ys.head - val head1 = f(head0) - if (head1 eq head0) { - loop(ys.tail) - } else { - val ys1 = head1 :: mapConserve(ys.tail)(f) - if (xs eq ys) ys1 - else { - val b = new ListBuffer[A] - var xc = xs - while (xc ne ys) { - b += xc.head - xc = xc.tail - } - b.prependToList(ys1) - } - } - } - loop(xs) - } - - /** Returns the list resulting from applying the given function `f` - * to corresponding elements of the argument lists. - * - * @param f function to apply to each pair of elements. - * @return `[f(a,,0,,,b,,0,,), ..., f(a,,n,,,b,,n,,)]` if the lists are - * `[a,,0,,, ..., a,,k,,]`, `[b,,0,,, ..., b,,l,,]` and - * `n = min(k,l)` - */ - @deprecated("use `(xs, ys).zipped.map(f)` instead of `List.map2(xs, ys)(f)`", "2.8.0") - def map2[A,B,C](xs: List[A], ys: List[B])(f: (A, B) => C): List[C] = { - val b = new ListBuffer[C] - var xc = xs - var yc = ys - while (!xc.isEmpty && !yc.isEmpty) { - b += f(xc.head, yc.head) - xc = xc.tail - yc = yc.tail - } - b.toList - } - - /** Returns the list resulting from applying the given function - * `f` to corresponding elements of the argument lists. - * - * @param f function to apply to each pair of elements. - * @return `[f(a,,0,,,b,,0,,,c,,0,,), ..., f(a,,n,,,b,,n,,,c,,n,,)]` - * if the lists are `[a,,0,,, ..., a,,k,,]`, - * `[b<sub>0</sub>, ..., b,,l,,]`, - * `[c<sub>0</sub>, ..., c,,m,,]` and `n = min(k,l,m)` - */ - @deprecated("use `(xs, ys, zs).zipped.map(f)` instead of `List.map3(xs, ys, zs)(f)`", "2.8.0") - def map3[A,B,C,D](xs: List[A], ys: List[B], zs: List[C])(f: (A, B, C) => D): List[D] = { - val b = new ListBuffer[D] - var xc = xs - var yc = ys - var zc = zs - while (!xc.isEmpty && !yc.isEmpty && !zc.isEmpty) { - b += f(xc.head, yc.head, zc.head) - xc = xc.tail - yc = yc.tail - zc = zc.tail - } - b.toList - } - - /** Tests whether the given predicate `p` holds - * for all corresponding elements of the argument lists. - * - * @param p function to apply to each pair of elements. - * @return `(p(a<sub>0</sub>,b<sub>0</sub>) && - * ... && p(a<sub>n</sub>,b<sub>n</sub>))]` - * if the lists are `[a<sub>0</sub>, ..., a<sub>k</sub>]`; - * `[b<sub>0</sub>, ..., b<sub>l</sub>]` - * and `n = min(k,l)` - */ - @deprecated("use `(xs, ys).zipped.forall(f)` instead of `List.forall2(xs, ys)(f)`", "2.8.0") - def forall2[A,B](xs: List[A], ys: List[B])(f: (A, B) => Boolean): Boolean = { - var xc = xs - var yc = ys - while (!xc.isEmpty && !yc.isEmpty) { - if (!f(xc.head, yc.head)) return false - xc = xc.tail - yc = yc.tail - } - true - } - - /** Tests whether the given predicate `p` holds - * for some corresponding elements of the argument lists. - * - * @param p function to apply to each pair of elements. - * @return `n != 0 && (p(a<sub>0</sub>,b<sub>0</sub>) || - * ... || p(a<sub>n</sub>,b<sub>n</sub>))]` if the lists are - * `[a<sub>0</sub>, ..., a<sub>k</sub>]`, - * `[b<sub>0</sub>, ..., b<sub>l</sub>]` and - * `n = min(k,l)` - */ - @deprecated("use `(xs, ys).zipped.exists(f)` instead of `List.exists2(xs, ys)(f)`", "2.8.0") - def exists2[A,B](xs: List[A], ys: List[B])(f: (A, B) => Boolean): Boolean = { - var xc = xs - var yc = ys - while (!xc.isEmpty && !yc.isEmpty) { - if (f(xc.head, yc.head)) return true - xc = xc.tail - yc = yc.tail - } - false - } - - /** Transposes a list of lists. - * pre: All element lists have the same length. - * - * @param xss the list of lists - * @return the transposed list of lists - */ - @deprecated("use `xss.transpose` instead of `List.transpose(xss)`", "2.8.0") - def transpose[A](xss: List[List[A]]): List[List[A]] = { - val buf = new ListBuffer[List[A]] - var yss = xss - while (!yss.head.isEmpty) { - buf += (yss map (_.head)) - yss = (yss map (_.tail)) - } - buf.toList - } } /** Only used for list serialization */ diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala index ea16e04ebe..82cf050f43 100644 --- a/src/library/scala/collection/immutable/Map.scala +++ b/src/library/scala/collection/immutable/Map.scala @@ -93,16 +93,6 @@ object Map extends ImmutableMapFactory[Map] { def - (key: Any): Map[Any, Nothing] = this } - @deprecated("use `Map.empty` instead", "2.8.0") - class EmptyMap[A,B] extends Map[A,B] with Serializable { - override def size: Int = 0 - def get(key: A): Option[B] = None - def iterator: Iterator[(A, B)] = Iterator.empty - override def updated [B1] (key: A, value: B1): Map[A, B1] = new Map1(key, value) - def + [B1](kv: (A, B1)): Map[A, B1] = updated(kv._1, kv._2) - def - (key: A): Map[A, B] = this - } - class Map1[A, +B](key1: A, value1: B) extends Map[A, B] with Serializable { override def size = 1 def get(key: A): Option[B] = diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala index 75c3845f04..892f75ae91 100644 --- a/src/library/scala/collection/immutable/Queue.scala +++ b/src/library/scala/collection/immutable/Queue.scala @@ -129,7 +129,4 @@ object Queue extends SeqFactory[Queue] { override def apply[A](xs: A*): Queue[A] = new Queue[A](Nil, xs.toList) private object EmptyQueue extends Queue[Nothing](Nil, Nil) { } - - @deprecated("Use Queue.empty instead", "2.8.0") - val Empty: Queue[Nothing] = Queue() } diff --git a/src/library/scala/collection/immutable/RedBlack.scala b/src/library/scala/collection/immutable/RedBlack.scala index bac60ac4f9..9906c9896e 100644 --- a/src/library/scala/collection/immutable/RedBlack.scala +++ b/src/library/scala/collection/immutable/RedBlack.scala @@ -35,12 +35,8 @@ abstract class RedBlack[A] extends Serializable { def delete(k: A): Tree[B] = blacken(del(k)) def range(from: Option[A], until: Option[A]): Tree[B] = blacken(rng(from, until)) def foreach[U](f: (A, B) => U) - @deprecated("use `foreach` instead", "2.8.0") - def visit[T](input: T)(f: (T, A, B) => (Boolean, T)): (Boolean, T) def toStream: Stream[(A,B)] def iterator: Iterator[(A, B)] - @deprecated("use `iterator` instead", "2.8.0") - def elements = iterator def upd[B1 >: B](k: A, v: B1): Tree[B1] def del(k: A): Tree[B] def smallest: NonEmpty[B] @@ -165,14 +161,6 @@ abstract class RedBlack[A] extends Serializable { right foreach f } - @deprecated("use `foreach` instead", "2.8.0") - def visit[T](input: T)(f: (T,A,B) => (Boolean, T)): (Boolean, T) = { - val left = this.left.visit(input)(f) - if (!left._1) return left - val middle = f(left._2, key, value) - if (!middle._1) return middle - return this.right.visit(middle._2)(f) - } override def rng(from: Option[A], until: Option[A]): Tree[B] = { if (from == None && until == None) return this if (from != None && isSmaller(key, from.get)) return right.rng(from, until); @@ -281,9 +269,6 @@ abstract class RedBlack[A] extends Serializable { def foreach[U](f: (A, Nothing) => U) {} - @deprecated("use `foreach` instead", "2.8.0") - def visit[T](input: T)(f: (T, A, Nothing) => (Boolean, T)) = (true, input) - def rng(from: Option[A], until: Option[A]) = this def first = throw new NoSuchElementException("empty map") def last = throw new NoSuchElementException("empty map") diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala index cb2823aeda..89be64b1d2 100644 --- a/src/library/scala/collection/immutable/Set.scala +++ b/src/library/scala/collection/immutable/Set.scala @@ -58,16 +58,6 @@ object Set extends ImmutableSetFactory[Set] { override def foreach[U](f: Any => U): Unit = {} } - @deprecated("use `Set.empty` instead", "2.8.0") - class EmptySet[A] extends Set[A] with Serializable { - override def size: Int = 0 - def contains(elem: A): Boolean = false - def + (elem: A): Set[A] = new Set1(elem) - def - (elem: A): Set[A] = this - def iterator: Iterator[A] = Iterator.empty - override def foreach[U](f: A => U): Unit = {} - } - /** An optimized representation for immutable sets of size 1 */ @SerialVersionUID(1233385750652442003L) class Set1[A] private[collection] (elem1: A) extends Set[A] with Serializable { diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala index b172908f85..238b3e414f 100644 --- a/src/library/scala/collection/immutable/Stack.scala +++ b/src/library/scala/collection/immutable/Stack.scala @@ -20,9 +20,6 @@ object Stack extends SeqFactory[Stack] { /** $genericCanBuildFromInfo */ implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, Stack[A]] = ReusableCBF.asInstanceOf[GenericCanBuildFrom[A]] def newBuilder[A]: Builder[A, Stack[A]] = new ArrayBuffer[A] mapResult (buf => new Stack(buf.toList)) - - @deprecated("Use Stack.empty instead", "2.8.0") - val Empty: Stack[Nothing] = Stack() } /** This class implements immutable stacks using a list-based data diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index c32c5b3640..47bd5610b2 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -605,9 +605,6 @@ object Stream extends SeqFactory[Stream] { else Some((xs.head, xs.tail)) } - @deprecated("use #:: instead", "2.8.0") - lazy val lazy_:: = #:: - /** An alternative way of building and matching Streams using Stream.cons(hd, tl). */ object cons { @@ -702,54 +699,6 @@ object Stream extends SeqFactory[Stream] { private[immutable] def collectedTail[A, B, That](stream: Stream[A], pf: PartialFunction[A, B], bf: CanBuildFrom[Stream[A], B, That]) = { cons(pf(stream.head), stream.tail.collect(pf)(bf).asInstanceOf[Stream[B]]) } - - /** A stream containing all elements of a given iterator, in the order they are produced. - * @param it The iterator producing the stream's elements - */ - @deprecated("use it.toStream instead", "2.8.0") - def fromIterator[A](it: Iterator[A]): Stream[A] = it.toStream - - /** The concatenation of a sequence of streams - */ - @deprecated("use xs.flatten instead", "2.8.0") - def concat[A](xs: Iterable[Stream[A]]): Stream[A] = concat(xs.iterator) - - /** The concatenation of all streams returned by an iterator - */ - @deprecated("use xs.toStream.flatten instead", "2.8.0") - def concat[A](xs: Iterator[Stream[A]]): Stream[A] = xs.toStream.flatten //(conforms[Stream[A], scala.collection.Traversable[A]]) - - /** - * Create a stream with element values `v,,n+1,, = step(v,,n,,)` where - * `v,,0,, = start` and elements are in the range between `start` (inclusive) - * and `end` (exclusive). - * - * @param start the start value of the stream - * @param end the end value of the stream - * @param step the increment function of the stream, must be monotonically increasing or decreasing - * @return the stream starting at value `start`. - */ - @deprecated("use `iterate` instead.", "2.8.0") - def range(start: Int, end: Int, step: Int => Int): Stream[Int] = - iterate(start, end - start)(step) - - /** - * Create an infinite stream containing the given element. - * - * @param elem the element composing the resulting stream - * @return the stream containing an infinite number of elem - */ - @deprecated("use `continually` instead", "2.8.0") - def const[A](elem: A): Stream[A] = cons(elem, const(elem)) - - /** Create a stream containing several copies of an element. - * - * @param n the length of the resulting stream - * @param elem the element composing the resulting stream - * @return the stream composed of n elements all equal to elem - */ - @deprecated("use fill(n, elem) instead", "2.8.0") - def make[A](n: Int, elem: A): Stream[A] = fill(n)(elem) } diff --git a/src/library/scala/collection/mutable/AddingBuilder.scala b/src/library/scala/collection/mutable/AddingBuilder.scala deleted file mode 100644 index d7f739d240..0000000000 --- a/src/library/scala/collection/mutable/AddingBuilder.scala +++ /dev/null @@ -1,36 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.collection -package mutable - -import generic._ - -/** The canonical builder for collections that are addable, i.e. that support - * an efficient `+` method which adds an element to the collection. - * - * Collections are built from their empty element using this `+` method. - * @param empty the empty element of the collection. - * @tparam Elem the type of elements that get added to the builder. - * @tparam To the type of the built collection. - * - * @note "efficient `+`" is not idle talk. Do not use this on mutable collections or any others - * for which `+` may perform an unshared copy! See GrowingBuilder comments for more. - * - * @author Martin Odersky - * @version 2.8 - * @since 2.8 - */ -@deprecated("Will be removed after scala 2.9", "2.8.0") -class AddingBuilder[Elem, To <: Addable[Elem, To] with collection.Iterable[Elem] with collection.IterableLike[Elem, To]](empty: To) -extends Builder[Elem, To] { - protected var elems: To = empty - def +=(x: Elem): this.type = { elems = elems + x; this } - def clear() { elems = empty } - def result: To = elems -} diff --git a/src/library/scala/collection/mutable/ArrayLike.scala b/src/library/scala/collection/mutable/ArrayLike.scala index bae6bd1164..62f2620498 100644 --- a/src/library/scala/collection/mutable/ArrayLike.scala +++ b/src/library/scala/collection/mutable/ArrayLike.scala @@ -46,22 +46,4 @@ trait ArrayLike[A, +Repr] extends IndexedSeqOptimized[A, Repr] { self => } override def stringPrefix = "Array" } - - @deprecated("use deep.toString instead", "2.8.0") - final def deepToString() = - deep.toString - - @deprecated("use deep.mkString instead", "2.8.0") - final def deepMkString(start: String, sep: String, end: String): String = - deep.mkString(start, sep, end) - - @deprecated("use deep.mkString instead", "2.8.0") - final def deepMkString(sep: String): String = - deepMkString("", sep, "") - - @deprecated("use array1.deep.equals(array2.deep) instead", "2.8.0") - final def deepEquals(that: Any): Boolean = that match { - case x: AnyRef if x.getClass.isArray => deep.equals(WrappedArray.make(x).deep) - case _ => false - } } diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala index b8d817f310..23af7d481e 100644 --- a/src/library/scala/collection/mutable/ArrayStack.scala +++ b/src/library/scala/collection/mutable/ArrayStack.scala @@ -117,10 +117,6 @@ extends Seq[T] x } - /** View the top element of the stack. */ - @deprecated("use top instead", "2.8.0") - def peek = top - /** View the top element of the stack. * * Does not remove the element on the top. If the stack is empty, diff --git a/src/library/scala/collection/mutable/BufferLike.scala b/src/library/scala/collection/mutable/BufferLike.scala index 067911f75e..acf26e59eb 100644 --- a/src/library/scala/collection/mutable/BufferLike.scala +++ b/src/library/scala/collection/mutable/BufferLike.scala @@ -214,51 +214,6 @@ trait BufferLike[A, +This <: BufferLike[A, This] with Buffer[A]] */ def readOnly: scala.collection.Seq[A] = toSeq - /** Adds a number of elements in an array - * - * @param src the array - * @param start the first element to append - * @param len the number of elements to append - */ - @deprecated("replace by: `buf ++= src.view(start, end)`", "2.8.0") - def ++=(src: Array[A], start: Int, len: Int) { - var i = start - val end = i + len - while (i < end) { - this += src(i) - i += 1 - } - } - - /** Adds a single element to this collection and returns - * the collection itself. - * - * $compatMutate - * You are strongly recommended to use `+=` instead. - * - * @param elem the element to add. - */ - @deprecated("Use += instead if you intend to add by side effect to an existing collection.\n"+ - "Use `clone() +=` if you intend to create a new collection.", "2.8.0") - def + (elem: A): This = { +=(elem); repr } - - /** Adds two or more elements to this collection and returns - * the collection itself. - * - * $compatMutate - * You are strongly recommended to use `++=` instead. - * - * @param elem1 the first element to add. - * @param elem2 the second element to add. - * @param elems the remaining elements to add. - */ - @deprecated("Use ++= instead if you intend to add by side effect to an existing collection.\n"+ - "Use `clone() ++=` if you intend to create a new collection.", "2.8.0") - def + (elem1: A, elem2: A, elems: A*): This = { - this += elem1 += elem2 ++= elems - repr - } - /** Creates a new collection containing both the elements of this collection and the provided * traversable object. * diff --git a/src/library/scala/collection/mutable/BufferProxy.scala b/src/library/scala/collection/mutable/BufferProxy.scala index f7831a7d3f..6a6bdd0077 100644 --- a/src/library/scala/collection/mutable/BufferProxy.scala +++ b/src/library/scala/collection/mutable/BufferProxy.scala @@ -38,16 +38,6 @@ trait BufferProxy[A] extends Buffer[A] with Proxy { def apply(n: Int): A = self.apply(n) - /** Append a single element to this buffer and return - * the identity of the buffer. - * - * @param elem the element to append. - * @return the updated buffer. - */ - @deprecated("Use += instead if you intend to add by side effect to an existing collection.\n"+ - "Use `clone() ++=` if you intend to create a new collection.", "2.8.0") - override def +(elem: A): Buffer[A] = self.+(elem) - /** Append a single element to this buffer. * * @param elem the element to append. @@ -56,16 +46,6 @@ trait BufferProxy[A] extends Buffer[A] with Proxy { override def readOnly = self.readOnly - /** Appends a number of elements provided by a traversable object via its - * `foreach` method. The identity of the buffer is returned. - * - * @param iter the traversable object. - * @return the updated buffer. - */ - @deprecated("Use ++= instead if you intend to add by side effect to an existing collection.\n"+ - "Use `clone() ++=` if you intend to create a new collection.", "2.8.0") - override def ++(xs: GenTraversableOnce[A]): Buffer[A] = self.++(xs) - /** Appends a number of elements provided by a traversable object. * * @param xs the traversable object. diff --git a/src/library/scala/collection/mutable/HashTable.scala b/src/library/scala/collection/mutable/HashTable.scala index 004b112253..ffde88575a 100644 --- a/src/library/scala/collection/mutable/HashTable.scala +++ b/src/library/scala/collection/mutable/HashTable.scala @@ -196,10 +196,6 @@ trait HashTable[A, Entry >: Null <: HashEntry[A, Entry]] extends HashTable.HashU } } - /** An iterator returning all entries */ - @deprecated("use entriesIterator instead", "2.8.0") - protected def entries: Iterator[Entry] = entriesIterator - /** Remove all entries from table */ protected def clearTable() { diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala index 8e01908a97..c2fca46a8b 100644 --- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala @@ -54,9 +54,6 @@ extends Map[A, B] with Serializable def iterator: Iterator[(A, B)] = imap.iterator - @deprecated("use `iterator` instead", "2.8.0") - override def elements = iterator - override def toList: List[(A, B)] = imap.toList override def update(key: A, value: B): Unit = { imap = imap.updated(key, value) } diff --git a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala index 2c1da15153..c44b77a9c4 100644 --- a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala @@ -40,9 +40,6 @@ class ImmutableSetAdaptor[A](protected var set: immutable.Set[A]) extends Set[A] def iterator: Iterator[A] = set.iterator - @deprecated("use `iterator` instead", "2.8.0") - override def elements: Iterator[A] = iterator - def +=(elem: A): this.type = { set = set + elem; this } def -=(elem: A): this.type = { set = set - elem; this } diff --git a/src/library/scala/collection/mutable/MapLike.scala b/src/library/scala/collection/mutable/MapLike.scala index 38de28f084..e4b1458e53 100644 --- a/src/library/scala/collection/mutable/MapLike.scala +++ b/src/library/scala/collection/mutable/MapLike.scala @@ -160,13 +160,6 @@ trait MapLike[A, B, +This <: MapLike[A, B, This] with Map[A, B]] ) override def -(key: A): This = clone() -= key - /** If given key is defined in this map, remove it and return associated value as an Option. - * If key is not present return None. - * @param key the key to be removed - */ - @deprecated("Use `remove` instead", "2.8.0") - def removeKey(key: A): Option[B] = remove(key) - /** Removes all bindings from the map. After this operation has completed, * the map will be empty. */ diff --git a/src/library/scala/collection/mutable/MultiMap.scala b/src/library/scala/collection/mutable/MultiMap.scala index 128ec0ff10..0f298c4a8a 100644 --- a/src/library/scala/collection/mutable/MultiMap.scala +++ b/src/library/scala/collection/mutable/MultiMap.scala @@ -36,9 +36,6 @@ trait MultiMap[A, B] extends Map[A, Set[B]] { */ protected def makeSet: Set[B] = new HashSet[B] - @deprecated("use addBinding instead", "2.8.0") - def add(key: A, value: B): this.type = addBinding(key, value) - /** Assigns the specified `value` to a specified `key`, replacing * the existing value assigned to that `key` if it is equal to * the specified value. Otherwise, simply adds another binding to diff --git a/src/library/scala/collection/mutable/MutableList.scala b/src/library/scala/collection/mutable/MutableList.scala index dbabeafd0a..b7eab5c2a9 100644 --- a/src/library/scala/collection/mutable/MutableList.scala +++ b/src/library/scala/collection/mutable/MutableList.scala @@ -105,9 +105,6 @@ extends LinearSeq[A] } } - @deprecated("use clear() instead", "2.8.0") - def reset() { clear() } - /** Returns an iterator over all elements of this list. */ override def iterator: Iterator[A] = first0.iterator diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala index f67aabc62d..469d2de495 100644 --- a/src/library/scala/collection/mutable/PriorityQueue.scala +++ b/src/library/scala/collection/mutable/PriorityQueue.scala @@ -91,23 +91,6 @@ class PriorityQueue[A](implicit val ord: Ordering[A]) } } - @deprecated( - "Use `+=` instead if you intend to add by side effect to an existing collection.\n"+ - "Use `clone() +=` if you intend to create a new collection.", "2.8.0" - ) - def +(elem: A): PriorityQueue[A] = { this.clone() += elem } - - /** Add two or more elements to this set. - * @param elem1 the first element. - * @param kv2 the second element. - * @param kvs the remaining elements. - */ - @deprecated( - "Use `++=` instead if you intend to add by side effect to an existing collection.\n"+ - "Use `clone() ++=` if you intend to create a new collection.", "2.8.0" - ) - def +(elem1: A, elem2: A, elems: A*) = { this.clone().+=(elem1, elem2, elems : _*) } - /** Inserts a single element into the priority queue. * * @param elem the element to insert. diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala index aa79d3df7e..0b3852fe61 100644 --- a/src/library/scala/collection/mutable/Stack.scala +++ b/src/library/scala/collection/mutable/Stack.scala @@ -121,10 +121,6 @@ extends Seq[A] */ def pushAll(xs: TraversableOnce[A]): this.type = { xs.seq foreach push ; this } - @deprecated("use pushAll", "2.8.0") - @migration(2, 8, "Stack ++= now pushes arguments on the stack from left to right.") - def ++=(xs: TraversableOnce[A]): this.type = pushAll(xs) - /** Returns the top element of the stack. This method will not remove * the element from the stack. An error is signaled if there is no * element on the stack. diff --git a/src/library/scala/collection/mutable/StackProxy.scala b/src/library/scala/collection/mutable/StackProxy.scala index d5439a1531..8884f03bbd 100644 --- a/src/library/scala/collection/mutable/StackProxy.scala +++ b/src/library/scala/collection/mutable/StackProxy.scala @@ -49,16 +49,6 @@ trait StackProxy[A] extends Stack[A] with Proxy { override def pushAll(xs: TraversableOnce[A]): this.type = { self pushAll xs; this } - /** Pushes all elements provided by an `Iterable` object on top of the - * stack. The elements are pushed in the order they are given out by - * the iterator. - * - * @param iter an iterable object - */ - @deprecated("use pushAll", "2.8.0") - override def ++=(xs: TraversableOnce[A]): this.type = { self ++= xs ; this } - - override def push(elem1: A, elem2: A, elems: A*): this.type = { self.push(elem1).push(elem2).pushAll(elems) this diff --git a/src/library/scala/collection/mutable/StringBuilder.scala b/src/library/scala/collection/mutable/StringBuilder.scala index c1558f522f..2cfab4713c 100644 --- a/src/library/scala/collection/mutable/StringBuilder.scala +++ b/src/library/scala/collection/mutable/StringBuilder.scala @@ -89,10 +89,6 @@ final class StringBuilder(private val underlying: JavaStringBuilder) */ def capacity: Int = underlying.capacity() - @deprecated("Use `ensureCapacity` instead. An assignment is misleading because\n"+ - "it can never decrease the capacity.", "2.8.0") - def capacity_=(n: Int) { ensureCapacity(n) } - /** Ensure that the capacity is at least the given argument. * If the argument is greater than the current capacity, new * storage will be allocated with size equal to the given @@ -368,31 +364,6 @@ final class StringBuilder(private val underlying: JavaStringBuilder) def insert(index: Int, x: Double): StringBuilder = insert(index, String.valueOf(x)) def insert(index: Int, x: Char): StringBuilder = insert(index, String.valueOf(x)) - @deprecated("Use appendAll instead. This method is deprecated because of the\n"+ - "possible confusion with `append(Any)`.", "2.8.0") - def append(x: Seq[Char]): StringBuilder = appendAll(x) - - @deprecated("use appendAll instead. This method is deprecated because\n"+ - "of the possible confusion with `append(Any)`.", "2.8.0") - def append(x: Array[Char]): StringBuilder = appendAll(x) - - @deprecated("use appendAll instead. This method is deprecated because\n"+ - "of the possible confusion with `append(Any, Int, Int)'.", "2.8.0") - def append(x: Array[Char], offset: Int, len: Int): StringBuilder = appendAll(x, offset, len) - - @deprecated("use insertAll instead. This method is deprecated because of the\n"+ - "possible confusion with `insert(Int, Any, Int, Int)'.", "2.8.0") - def insert(index: Int, str: Array[Char], offset: Int, len: Int): StringBuilder = - insertAll(index, str, offset, len) - - @deprecated("use insertAll instead. This method is deprecated because of\n"+ - "the possible confusion with `insert(Int, Any)'.", "2.8.0") - def insert(at: Int, x: Seq[Char]): StringBuilder = insertAll(at, x) - - @deprecated("use insertAll instead. This method is deprecated because of\n"+ - "the possible confusion with `insert(Int, Any)'.", "2.8.0") - def insert(at: Int, x: Array[Char]): StringBuilder = insertAll(at, x) - /** Finds the index of the first occurrence of the specified substring. * * @param str the target string to search for diff --git a/src/library/scala/collection/mutable/SynchronizedBuffer.scala b/src/library/scala/collection/mutable/SynchronizedBuffer.scala index d55ce8d684..23552e9d52 100644 --- a/src/library/scala/collection/mutable/SynchronizedBuffer.scala +++ b/src/library/scala/collection/mutable/SynchronizedBuffer.scala @@ -40,15 +40,6 @@ trait SynchronizedBuffer[A] extends Buffer[A] { super.apply(n) } - /** Append a single element to this buffer and return - * the identity of the buffer. - * - * @param elem the element to append. - */ - override def +(elem: A): Self = synchronized { - super.+(elem) - } - /** Append a single element to this buffer. * * @param elem the element to append. diff --git a/src/library/scala/concurrent/MailBox.scala b/src/library/scala/concurrent/MailBox.scala deleted file mode 100644 index 6f9e39d8de..0000000000 --- a/src/library/scala/concurrent/MailBox.scala +++ /dev/null @@ -1,177 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.concurrent - -/** This class ... - * - * @author Martin Odersky - * @version 1.0, 12/03/2003 - */ -//class MailBox with Monitor with LinkedListQueueCreator { -@deprecated("use actors instead", "2.8.0") -class MailBox extends AnyRef with ListQueueCreator { - - type Message = AnyRef - - private abstract class PreReceiver { - var msg: Message = null - def isDefinedAt(msg: Message): Boolean - } - - private class Receiver[A](receiver: PartialFunction[Message, A]) extends PreReceiver { - - def isDefinedAt(msg: Message) = receiver.isDefinedAt(msg) - - def receive(): A = synchronized { - while (msg eq null) wait() - receiver(msg) - } - - def receiveWithin(msec: Long): A = synchronized { - if (msg eq null) wait(msec) - receiver(if (msg ne null) msg else TIMEOUT) - } - } - - private val messageQueue = queueCreate[Message] - private val receiverQueue = queueCreate[PreReceiver] - - /** Unconsumed messages. */ - private var sent = messageQueue.make - - /** Pending receivers. */ - private var receivers = receiverQueue.make - - /** - * Check whether the receiver can be applied to an unconsumed message. - * If yes, the message is extracted and associated with the receiver. - * Otherwise the receiver is appended to the list of pending receivers. - */ - private def scanSentMsgs[A](receiver: Receiver[A]): Unit = synchronized { - messageQueue.extractFirst(sent, msg => receiver.isDefinedAt(msg)) match { - case None => - receivers = receiverQueue.append(receivers, receiver) - case Some((msg, withoutMsg)) => - sent = withoutMsg - receiver.msg = msg - } - } - - /** - * First check whether a pending receiver is applicable to the sent - * message. If yes, the receiver is notified. Otherwise the message - * is appended to the linked list of sent messages. - */ - def send(msg: Message): Unit = synchronized { - receiverQueue.extractFirst(receivers, r => r.isDefinedAt(msg)) match { - case None => - sent = messageQueue.append(sent, msg) - case Some((receiver, withoutReceiver)) => - receivers = withoutReceiver - receiver.msg = msg - receiver synchronized { receiver.notify() } - } - } - - /** - * Block until there is a message in the mailbox for which the processor - * `f` is defined. - */ - def receive[A](f: PartialFunction[Message, A]): A = { - val r = new Receiver(f) - scanSentMsgs(r) - r.receive() - } - - /** - * Block until there is a message in the mailbox for which the processor - * `f` is defined or the timeout is over. - */ - def receiveWithin[A](msec: Long)(f: PartialFunction[Message, A]): A = { - val r = new Receiver(f) - scanSentMsgs(r) - r.receiveWithin(msec) - } - -} - - - -/** -* Module for dealing with queues. -*/ -@deprecated("use actors instead", "2.8.0") -trait QueueModule[A] { - /** Type of queues. */ - type T - /** Create an empty queue. */ - def make: T - /** Append an element to a queue. */ - def append(l: T, x: A): T - /** Extract an element satisfying a predicate from a queue. */ - def extractFirst(l: T, p: A => Boolean): Option[(A, T)] -} - -/** Inefficient but simple queue module creator. */ -@deprecated("use actors instead", "2.8.0") -trait ListQueueCreator { - def queueCreate[A]: QueueModule[A] = new QueueModule[A] { - type T = List[A] - def make: T = Nil - def append(l: T, x: A): T = l ::: x :: Nil - def extractFirst(l: T, p: A => Boolean): Option[(A, T)] = - l match { - case Nil => None - case head :: tail => - if (p(head)) - Some((head, tail)) - else - extractFirst(tail, p) match { - case None => None - case Some((x, without_x)) => Some((x, head :: without_x)) - } - } - } -} - -/** Efficient queue module creator based on linked lists. */ -@deprecated("use actors instead", "2.8.0") -trait LinkedListQueueCreator { - import scala.collection.mutable.LinkedList - def queueCreate[A >: Null <: AnyRef]: QueueModule[A] = new QueueModule[A] { - type T = (LinkedList[A], LinkedList[A]) // fst = the list, snd = last elem - def make: T = { - val l = new LinkedList[A](null, null) - (l, l) - } - def append(l: T, x: A): T = { - val atTail = new LinkedList(x, null) - l._2 append atTail; - (l._1, atTail) - } - def extractFirst(l: T, p: A => Boolean): Option[(A, T)] = { - var xs = l._1 - var xs1 = xs.next - while ((xs1 ne null) && !p(xs1.elem)) { - xs = xs1 - xs1 = xs1.next - } - if (xs1 ne null) { - xs.next = xs1.next - if (xs.next eq null) - Some((xs1.elem, (l._1, xs))) - else - Some((xs1.elem, l)) - } - else - None - } - } -} - diff --git a/src/library/scala/concurrent/TIMEOUT.scala b/src/library/scala/concurrent/TIMEOUT.scala deleted file mode 100644 index d0328928fa..0000000000 --- a/src/library/scala/concurrent/TIMEOUT.scala +++ /dev/null @@ -1,19 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.concurrent - -/** - * The message sent to a message box when the period specified in - * `receiveWithin` expires. - * - * @author Martin Odersky - * @version 1.0, 10/03/2003 - */ -@deprecated("use actors instead", "2.8.0") -case object TIMEOUT diff --git a/src/library/scala/concurrent/ops.scala b/src/library/scala/concurrent/ops.scala index d0ea51db51..92220a8313 100644 --- a/src/library/scala/concurrent/ops.scala +++ b/src/library/scala/concurrent/ops.scala @@ -61,24 +61,6 @@ object ops (xp, getOrThrow(y.get)) } - /** - * @param start ... - * @param end ... - * @param p ... - */ - @deprecated("use `collection.parallel.ParIterable.foreach` instead", "2.9.0") - def replicate(start: Int, end: Int)(p: Int => Unit)(implicit runner: TaskRunner = defaultRunner) { - if (start == end) - () - else if (start + 1 == end) - p(start) - else { - val mid = (start + end) / 2 - spawn { replicate(start, mid)(p) } - replicate(mid, end)(p) - } - } - /* def parMap[a,b](f: a => b, xs: Array[a]): Array[b] = { val results = new Array[b](xs.length); diff --git a/src/library/scala/concurrent/pilib.scala b/src/library/scala/concurrent/pilib.scala deleted file mode 100644 index 246fe6d786..0000000000 --- a/src/library/scala/concurrent/pilib.scala +++ /dev/null @@ -1,206 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.concurrent - -/** Library for using Pi-calculus concurrent primitives in - * [[http://scala-lang.org/#_top Scala]]. As an example, the definition of - * a two-place buffer using the `pilib` library looks like: - * {{{ - * def Buffer[a](put: Chan[a], get: Chan[a]) { - * def B0 { choice ( put * { x => B1(x) } ) } - * def B1(x: a) { choice ( get(x) * B0, put * { y => B2(x, y) } ) } - * def B2(x: a, y: a) { choice ( get(x) * B1(y) ) } - * B0 - * } - * }}} - * - * @see <a href="http://scala-lang.org/docu/papers.html" target="_top"> - * PiLib: A Hosted Language for Pi-Calculus Style Concurrency</a> - * @author Vincent Cremet, Martin Odersky - * @version 1.0 - */ -@deprecated("use actors instead", "2.8.0") -object pilib { - - import TaskRunners.threadRunner - - //////////////////////////////// SPAWN ///////////////////////////////// - - /** - * Run several processes in parallel using the following syntax: - * `spawn < p,,1,, | ... | p,,n,, >`. - */ - abstract class Spawn { - def <(p: => Unit): Spawn - def |(p: => Unit): Spawn - def > (): Unit - } - val spawn = new Spawn { - //object spawn extends Spawn { // BUG ! - def <(p: => Unit): Spawn = { scala.concurrent.ops.spawn(p); this } - def |(p: => Unit): Spawn = { scala.concurrent.ops.spawn(p); this } - def > (): Unit = () - } - - /////////////////////////// GUARDED PROCESSES ////////////////////////// - - /** Untyped channel. */ - class UChan { - /** Default log function. */ - var log = (x: Any) => () - } - - /** An untyped guarded process. - * - * @param n channel name - * @param polarity input (true) or output (false) - * @param v transmitted value - * @param c continuation - */ - case class UGP(n: UChan, polarity: Boolean, v: Any, c: Any => Any) - - /** Typed guarded process. */ - class GP[a](n: UChan, polarity: Boolean, v: Any, c: Any => a) { - val untyped = UGP(n, polarity, v, c) - } - - //////////////////////////////// CHANNELS ////////////////////////////// - - /** - * Name on which one can emit, receive or that can be emitted or received - * during a communication. - */ - class Chan[A] extends UChan with Function1[A, Product[A]] { - - var defaultValue: A = _ - - /** Creates an input guarded process. */ - def input[B](c: A => B) = - new GP(this, true, (), x => c(x.asInstanceOf[A])) - - /** Creates an input guarded process. */ - def output[B](v: A, c: () => B) = - new GP(this, false, v, x => c()) - - /** Blocking read. */ - def read = { - var res: A = defaultValue - choice ( input(x => res = x) ) - res - } - - /** Blocking write. */ - def write(x: A) = - choice ( output(x, () => ()) ) - - /** Syntactic sugar for input. */ - def *[B](f: A => B) = - input(f) - - /** Syntactic sugar for output. */ - def apply(v: A) = - new Product(this, v) - - /** Attach a function to be evaluated at each communication event - * on this channel. Replace previous attached function. - */ - def attach(f: A => Unit) = - log = x => f(x.asInstanceOf[A]) - } - - class Product[A](c: Chan[A], v: A) { - def *[B](f: => B) = c.output(v, () => f) - } - - /////////////////////// SUM OF GUARDED PROCESSES /////////////////////// - - case class Sum(gs: List[UGP]) { - - /** Continuation of the sum. */ - var cont: () => Any = _ - - var initialized = false - - /** Block if not initialized otherwise continue with the - * continuation. - */ - def continue = synchronized { - if (!initialized) wait() - cont() - } - - /** Set the values of parameters and awake the sleeping sum. - * - * @param f ... - */ - def set(f: () => Any) = synchronized { - cont = f - initialized = true - notify() - } - } - - ///////////////////////////// COMMUNICATION //////////////////////////// - - private var sums: List[Sum] = Nil - - /** Test if two lists of guarded processes can communicate. - * - * @param gs1 ... - * @param gs2 ... - * @return ... - */ - private def matches(gs1: List[UGP], gs2: List[UGP]): Option[(() => Unit, () => Any, () => Any)] = - (gs1, gs2) match { - case (Nil, _) => None - case (_, Nil) => None - case (UGP(a1, d1, v1, c1) :: rest1, UGP(a2, d2, v2, c2) :: rest2) => - if (a1 == a2 && d1 == !d2) - Some(((() => if (d1) a1.log(v2) else a1.log(v1)), (() => c1(v2)), (() => c2(v1)))) - else matches(gs1, rest2) match { - case None => matches(rest1, gs2) - case Some(t) => Some(t) - } - } - - /** Test if the given sum can react with one of the pending sums. - * If yes then do the reaction otherwise append the sum at the end - * of the pending sums. - * - * @param s1 ... - * @param ss ... - * @return ... - */ - private def compare(s1: Sum, ss: List[Sum]): List[Sum] = - ss match { - case Nil => ss ::: List(s1) - case s2 :: rest => matches(s1.gs, s2.gs) match { - case None => s2 :: compare(s1, rest) - case Some((log, c1, c2)) => - log() - s1.set(c1) - s2.set(c2) - rest - } - } - - /** Pi-calculus non-deterministic choice. - * - * @param s ... - * @return ... - */ - def choice[A](s: GP[A]*): A = { - val sum = Sum(s.toList map { _.untyped }) - synchronized { sums = compare(sum, sums) } - (sum.continue).asInstanceOf[A] - } - -} diff --git a/src/library/scala/io/Source.scala b/src/library/scala/io/Source.scala index 09887efdae..6a96d6f285 100644 --- a/src/library/scala/io/Source.scala +++ b/src/library/scala/io/Source.scala @@ -187,15 +187,6 @@ abstract class Source extends Iterator[Char] { var nerrors = 0 var nwarnings = 0 - /** Convenience method, returns given line (not including newline) - * from Source. - * - * @param line the line index, first line is 1 - * @return the specified line. - * - */ - @deprecated("Use a collections method such as getLines().toIndexedSeq for random access.", "2.8.0") - def getLine(line: Int): String = lineNum(line) private def lineNum(line: Int): String = getLines() drop (line - 1) take 1 mkString class LineIterator() extends Iterator[String] { diff --git a/src/library/scala/io/UTF8Codec.scala b/src/library/scala/io/UTF8Codec.scala index 72a1dafc32..df0a36ef21 100644 --- a/src/library/scala/io/UTF8Codec.scala +++ b/src/library/scala/io/UTF8Codec.scala @@ -13,8 +13,7 @@ package scala.io * @author Martin Odersky * @version 1.0, 04/10/2004 */ -object UTF8Codec -{ +object UTF8Codec { final val UNI_REPLACEMENT_CHAR: Int = 0x0000FFFD final val UNI_REPLACEMENT_BYTES = Array[Byte](-17, -65, -67) @@ -29,36 +28,4 @@ object UTF8Codec // // Some useful locations: // http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt - - @deprecated("""Use new String(Array(ch), 0, 1).getBytes("UTF-8") instead""", "2.8.0") - def encode(ch: Int): Array[Byte] = - if ((Character getType ch) == Character.SURROGATE.toInt) UNI_REPLACEMENT_BYTES - else try new String(Array(ch), 0, 1) getBytes "UTF-8" catch { - case _: IllegalArgumentException => UNI_REPLACEMENT_BYTES - } - - @deprecated("Use Codec.toUTF8 instead", "2.8.0") - def encode(src: Array[Char], from: Int, dst: Array[Byte], to: Int, len: Int): Int = { - val bytes = Codec toUTF8 src.slice(from, from + len) - Array.copy(bytes, 0, dst, to, bytes.length) - bytes.length - } - - @deprecated("Use Codec.toUTF8 instead", "2.8.0") - def encode(s: String, dst: Array[Byte], to: Int): Int = - encode(s.toArray, 0, dst, to, s.length) - - @deprecated("Use Codec.toUTF8 instead", "2.8.0") - def encode(s: String): Array[Byte] = Codec toUTF8 s - - @deprecated("Use Codec.fromUTF8 instead", "2.8.0") - def decode(src: Array[Byte], from: Int, dst: Array[Char], to: Int, len: Int): Int = { - val chars = Codec fromUTF8 src.slice(from, from + len) - Array.copy(chars, 0, dst, to, chars.length) - chars.length - } - - @deprecated("Use Codec.fromUTF8 instead", "2.8.0") - def decode(src: Array[Byte], from: Int, len: Int): String = - Codec fromUTF8 src.slice(from, from + len) mkString } diff --git a/src/library/scala/math/package.scala b/src/library/scala/math/package.scala index 9e90b77fc6..8948722340 100644 --- a/src/library/scala/math/package.scala +++ b/src/library/scala/math/package.scala @@ -12,7 +12,130 @@ package scala * numeric operations such as elementary exponential, logarithmic, root and * trigonometric functions. */ -package object math extends MathCommon { +package object math { + /** The `double` value that is closer than any other to `e`, the base of + * the natural logarithms. + */ + val E = java.lang.Math.E + + /** The `double` value that is closer than any other to `pi`, the ratio of + * the circumference of a circle to its diameter. + */ + val Pi = java.lang.Math.PI + + /** Returns a `double` value with a positive sign, greater than or equal + * to `0.0` and less than `1.0`. + */ + def random: Double = java.lang.Math.random() + + def sin(x: Double): Double = java.lang.Math.sin(x) + def cos(x: Double): Double = java.lang.Math.cos(x) + def tan(x: Double): Double = java.lang.Math.tan(x) + def asin(x: Double): Double = java.lang.Math.asin(x) + def acos(x: Double): Double = java.lang.Math.acos(x) + def atan(x: Double): Double = java.lang.Math.atan(x) + + /** Converts an angle measured in degrees to an approximately equivalent + * angle measured in radians. + * + * @param x an angle, in degrees + * @return the measurement of the angle `x` in radians. + */ + def toRadians(x: Double): Double = java.lang.Math.toRadians(x) + + /** Converts an angle measured in radians to an approximately equivalent + * angle measured in degrees. + * + * @param x angle, in radians + * @return the measurement of the angle `x` in degrees. + */ + def toDegrees(x: Double): Double = java.lang.Math.toDegrees(x) + + /** Returns Euler's number `e` raised to the power of a `double` value. + * + * @param x the exponent to raise `e` to. + * @return the value `e^a^`, where `e` is the base of the natural + * logarithms. + */ + def exp(x: Double): Double = java.lang.Math.exp(x) + def log(x: Double): Double = java.lang.Math.log(x) + def sqrt(x: Double): Double = java.lang.Math.sqrt(x) + def IEEEremainder(x: Double, y: Double): Double = java.lang.Math.IEEEremainder(x, y) + + def ceil(x: Double): Double = java.lang.Math.ceil(x) + def floor(x: Double): Double = java.lang.Math.floor(x) + + /** Returns the `double` value that is closest in value to the + * argument and is equal to a mathematical integer. + * + * @param x a `double` value + * @return the closest floating-point value to a that is equal to a + * mathematical integer. + */ + def rint(x: Double): Double = java.lang.Math.rint(x) + + /** Converts rectangular coordinates `(x, y)` to polar `(r, theta)`. + * + * @param x the ordinate coordinate + * @param y the abscissa coordinate + * @return the ''theta'' component of the point `(r, theta)` in polar + * coordinates that corresponds to the point `(x, y)` in + * Cartesian coordinates. + */ + def atan2(y: Double, x: Double): Double = java.lang.Math.atan2(y, x) + + /** Returns the value of the first argument raised to the power of the + * second argument. + * + * @param x the base. + * @param y the exponent. + * @return the value `x^y^`. + */ + def pow(x: Double, y: Double): Double = java.lang.Math.pow(x, y) + + /** Returns the closest `long` to the argument. + * + * @param x a floating-point value to be rounded to a `long`. + * @return the value of the argument rounded to the nearest`long` value. + */ + def round(x: Float): Int = java.lang.Math.round(x) + def round(x: Double): Long = java.lang.Math.round(x) + def abs(x: Int): Int = java.lang.Math.abs(x) + def abs(x: Long): Long = java.lang.Math.abs(x) + def abs(x: Float): Float = java.lang.Math.abs(x) + def abs(x: Double): Double = java.lang.Math.abs(x) + + def max(x: Int, y: Int): Int = java.lang.Math.max(x, y) + def max(x: Long, y: Long): Long = java.lang.Math.max(x, y) + def max(x: Float, y: Float): Float = java.lang.Math.max(x, y) + def max(x: Double, y: Double): Double = java.lang.Math.max(x, y) + + def min(x: Int, y: Int): Int = java.lang.Math.min(x, y) + def min(x: Long, y: Long): Long = java.lang.Math.min(x, y) + def min(x: Float, y: Float): Float = java.lang.Math.min(x, y) + def min(x: Double, y: Double): Double = java.lang.Math.min(x, y) + + def signum(x: Double): Double = + if (x == 0d) 0d + else if (x < 0) -1.0 + else if (x > 0) 1.0 + else x // NaN + + def signum(x: Float): Float = + if (x == 0f) 0f + else if (x < 0) -1.0f + else if (x > 0) 1.0f + else x // NaN + + def signum(x: Long): Long = + if (x == 0l) 0l + else if (x < 0) -1l + else 1l + + def signum(x: Int): Int = + if (x == 0) 0 + else if (x < 0) -1 + else 1 // ----------------------------------------------------------------------- // root functions diff --git a/src/library/scala/package.scala b/src/library/scala/package.scala index 264fd18406..0c5d10b15e 100644 --- a/src/library/scala/package.scala +++ b/src/library/scala/package.scala @@ -123,70 +123,6 @@ package object scala { type unchecked = annotation.unchecked.unchecked type volatile = annotation.volatile */ - @deprecated("Use Tuple1(x) to create a 1-tuple.", "2.8.0") - def Tuple[A1](x1: A1) = Tuple1(x1) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2](x1: A1, x2: A2) = Tuple2(x1, x2) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3](x1: A1, x2: A2, x3: A3) = Tuple3(x1, x2, x3) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4](x1: A1, x2: A2, x3: A3, x4: A4) = Tuple4(x1, x2, x3, x4) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5) = Tuple5(x1, x2, x3, x4, x5) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6) = Tuple6(x1, x2, x3, x4, x5, x6) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7) = Tuple7(x1, x2, x3, x4, x5, x6, x7) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8) = Tuple8(x1, x2, x3, x4, x5, x6, x7, x8) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9) = Tuple9(x1, x2, x3, x4, x5, x6, x7, x8, x9) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10) = Tuple10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11) = Tuple11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12) = Tuple12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13) = Tuple13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13, x14: A14) = Tuple14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13, x14: A14, x15: A15) = Tuple15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13, x14: A14, x15: A15, x16: A16) = Tuple16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13, x14: A14, x15: A15, x16: A16, x17: A17) = Tuple17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13, x14: A14, x15: A15, x16: A16, x17: A17, x18: A18) = Tuple18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13, x14: A14, x15: A15, x16: A16, x17: A17, x18: A18, x19: A19) = Tuple19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13, x14: A14, x15: A15, x16: A16, x17: A17, x18: A18, x19: A19, x20: A20) = Tuple20(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13, x14: A14, x15: A15, x16: A16, x17: A17, x18: A18, x19: A19, x20: A20, x21: A21) = Tuple21(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) - @deprecated("Use ((x1, x2, ...)) syntax to create Tuples", "2.8.0") - def Tuple[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](x1: A1, x2: A2, x3: A3, x4: A4, x5: A5, x6: A6, x7: A7, x8: A8, x9: A9, x10: A10, x11: A11, x12: A12, x13: A13, x14: A14, x15: A15, x16: A16, x17: A17, x18: A18, x19: A19, x20: A20, x21: A21, x22: A22) = Tuple22(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) - - @deprecated("use java.lang.Integer instead", "2.6.0") - type Integer = java.lang.Integer - @deprecated("use java.lang.Character instead", "2.6.0") - type Character = java.lang.Character - - @deprecated("use Iterable instead", "2.8.0") - type Collection[+A] = Iterable[A] - @deprecated("use Iterable instead", "2.8.0") - val Collection = Iterable - - @deprecated("use Seq instead", "2.8.0") - type Sequence[+A] = scala.collection.Seq[A] - @deprecated("use Seq instead", "2.8.0") - val Sequence = scala.collection.Seq - - @deprecated("use IndexedSeq instead", "2.8.0") - type RandomAccessSeq[+A] = scala.collection.IndexedSeq[A] - @deprecated("use IndexedSeq instead", "2.8.0") - val RandomAccessSeq = scala.collection.IndexedSeq @deprecated("use scala.annotation.Annotation instead", "2.9.0") type Annotation = scala.annotation.Annotation diff --git a/src/library/scala/runtime/AnyValCompanion.scala b/src/library/scala/runtime/AnyValCompanion.scala deleted file mode 100644 index fdb0e8f638..0000000000 --- a/src/library/scala/runtime/AnyValCompanion.scala +++ /dev/null @@ -1,14 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.runtime - -/** See scala.AnyValCompanion. - */ -@deprecated("Use scala.AnyValCompanion instead", "2.8.0") -private[scala] trait AnyValCompanion extends scala.AnyValCompanion { }
\ No newline at end of file diff --git a/src/library/scala/runtime/RichChar.scala b/src/library/scala/runtime/RichChar.scala index 358faf47f5..ba939d6633 100644 --- a/src/library/scala/runtime/RichChar.scala +++ b/src/library/scala/runtime/RichChar.scala @@ -45,14 +45,4 @@ final class RichChar(val self: Char) extends IntegralProxy[Char] { // public static boolean isDefined(char ch) // public static boolean isJavaIdentifierStart(char ch) // public static boolean isJavaIdentifierPart(char ch) - - @deprecated("Use ch.toLower instead", "2.8.0") - def toLowerCase: Char = toLower - @deprecated("Use ch.toUpper instead", "2.8.0") - def toUpperCase: Char = toUpper - - @deprecated("Use ch.isLower instead", "2.8.0") - def isLowerCase: Boolean = isLower - @deprecated("Use ch.isUpper instead", "2.8.0") - def isUpperCase: Boolean = isUpper } diff --git a/src/library/scala/util/parsing/json/JSON.scala b/src/library/scala/util/parsing/json/JSON.scala index b0926d20e7..1464f80e3f 100644 --- a/src/library/scala/util/parsing/json/JSON.scala +++ b/src/library/scala/util/parsing/json/JSON.scala @@ -33,20 +33,6 @@ import scala.util.parsing.combinator.lexical._ object JSON extends Parser { /** - * Parse the given `JSON` string and return a list of elements. If the - * string is a `JSON` object it will be a list of pairs. If it's a `JSON` - * array it will be be a list of individual elements. - * - * @param input the given `JSON` string. - * @return an optional list of of elements. - */ - @deprecated("Use parseFull or parseRaw as needed.", "2.8.0") - def parse(input: String): Option[List[Any]] = parseRaw(input).map(unRaw).flatMap({ - case l : List[_] => Some(l) - case _ => None - }) - - /** * This method converts ''raw'' results back into the original, deprecated * form. */ diff --git a/src/library/scala/util/parsing/syntax/package.scala b/src/library/scala/util/parsing/syntax/package.scala deleted file mode 100644 index 59053e2f54..0000000000 --- a/src/library/scala/util/parsing/syntax/package.scala +++ /dev/null @@ -1,20 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2006-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.util.parsing - -import scala.util.parsing.combinator.token - -// If deprecating the whole package worked, that's what would best -// be done, but it doesn't (yet) so it isn't. -package object syntax { - @deprecated("Moved to scala.util.parsing.combinator.token", "2.8.0") - type Tokens = token.Tokens - @deprecated("Moved to scala.util.parsing.combinator.token", "2.8.0") - type StdTokens = token.StdTokens -} diff --git a/src/library/scala/xml/HasKeyValue.scala b/src/library/scala/xml/HasKeyValue.scala deleted file mode 100644 index 55ac63e201..0000000000 --- a/src/library/scala/xml/HasKeyValue.scala +++ /dev/null @@ -1,24 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.xml - -/** Use this class to match on (unprefixed) attribute values - * {{{ - * val hasName = new HasKeyValue("name") - * node match { - * case Node("foo", hasName(x), _*) => x // foo had attribute with key "name" and with value x - * } - * }}} - * - * @author Burak Emir - */ -@deprecated("Use UnprefixedAttribute's extractor", "2.8.0") -class HasKeyValue(key: String) { - def unapplySeq(x: MetaData): Option[Seq[Node]] = x.get(key) -} diff --git a/src/library/scala/xml/XML.scala b/src/library/scala/xml/XML.scala index 678028dd28..bc3033d081 100644 --- a/src/library/scala/xml/XML.scala +++ b/src/library/scala/xml/XML.scala @@ -49,14 +49,6 @@ object XML extends XMLLoader[Elem] def withSAXParser(p: SAXParser): XMLLoader[Elem] = new XMLLoader[Elem] { override val parser: SAXParser = p } - @deprecated("Use save() instead", "2.8.0") - final def saveFull(filename: String, node: Node, xmlDecl: Boolean, doctype: dtd.DocType): Unit = - save(filename, node, encoding, xmlDecl, doctype) - - @deprecated("Use save() instead", "2.8.0") - final def saveFull(filename: String, node: Node, enc: String, xmlDecl: Boolean, doctype: dtd.DocType): Unit = - save(filename, node, enc, xmlDecl, doctype) - /** Saves a node to a file with given filename using given encoding * optionally with xmldecl and doctype declaration. * |