Deprecated unused members in scala.concurrent.

5 files changed, 26 insertions, 14 deletions

diff --git a/src/library/scala/concurrent/FutureTaskRunner.scala b/src/library/scala/concurrent/FutureTaskRunner.scala
index fe3728861f..206155ce2a 100644
--- a/src/library/scala/concurrent/FutureTaskRunner.scala
+++ b/src/library/scala/concurrent/FutureTaskRunner.scala
@@ -1,25 +1,25 @@
 package scala.concurrent
 
-/** The <code>FutureTaskRunner</code> trait is a base trait of thread runners
- *  that provide some sort of future abstractions.
+/** The <code>FutureTaskRunner</code> trait is a base trait of task runners
+ *  that provide some sort of future abstraction.
  *
  *  @author Philipp Haller
  */
 trait FutureTaskRunner extends TaskRunner {
 
-  /** The type of the futures that are provided.
+  /** The type of the futures that the underlying task runner supports.
    */
   type Future[T]
 
-  /** An implicit conversion from futures to zero-parameter functions
+  /** An implicit conversion from futures to zero-parameter functions.
    */
   implicit def futureAsFunction[S](x: Future[S]): () => S
 
-  /** Submits a task to run which returns its result in a futir
+  /** Submits a task to run which returns its result in a future.
    */
   def submit[S](task: Task[S]): Future[S]
 
-   /* Possibly blocks the current thread, for example waiting for
+   /* Possibly blocks the current thread, for example, waiting for
     * a lock or condition.
     */
   def managedBlock(blocker: ManagedBlocker): Unit
diff --git a/src/library/scala/concurrent/MailBox.scala b/src/library/scala/concurrent/MailBox.scala
index 14b67bea3f..d9a8746ba3 100644
--- a/src/library/scala/concurrent/MailBox.scala
+++ b/src/library/scala/concurrent/MailBox.scala
@@ -16,6 +16,7 @@ package scala.concurrent
  *  @version 1.0, 12/03/2003
  */
 //class MailBox with Monitor with LinkedListQueueCreator {
+@deprecated("use actors instead")
 class MailBox extends AnyRef with ListQueueCreator {
 
   type Message = AnyRef
@@ -102,11 +103,12 @@ class MailBox extends AnyRef with ListQueueCreator {
 
 }
 
-/////////////////////////////////////////////////////////////////
+
 
 /**
 * Module for dealing with queues.
 */
+@deprecated("use actors instead")
 trait QueueModule[A] {
   /** Type of queues. */
   type T
@@ -119,6 +121,7 @@ trait QueueModule[A] {
 }
 
 /** Inefficient but simple queue module creator. */
+@deprecated("use actors instead")
 trait ListQueueCreator {
   def queueCreate[A]: QueueModule[A] = new QueueModule[A] {
     type T = List[A]
@@ -140,6 +143,7 @@ trait ListQueueCreator {
 }
 
 /** Efficient queue module creator based on linked lists. */
+@deprecated("use actors instead")
 trait LinkedListQueueCreator {
   import scala.collection.mutable.LinkedList
   def queueCreate[A >: Null <: AnyRef]: QueueModule[A] = new QueueModule[A] {
diff --git a/src/library/scala/concurrent/TIMEOUT.scala b/src/library/scala/concurrent/TIMEOUT.scala
index 7d3c0dfb4c..512879760b 100644
--- a/src/library/scala/concurrent/TIMEOUT.scala
+++ b/src/library/scala/concurrent/TIMEOUT.scala
@@ -17,4 +17,5 @@ package scala.concurrent
  * @author  Martin Odersky
  * @version 1.0, 10/03/2003
  */
+@deprecated("use actors instead")
 case object TIMEOUT
diff --git a/src/library/scala/concurrent/ops.scala b/src/library/scala/concurrent/ops.scala
index 4d6f4b29b1..06f745e26b 100644
--- a/src/library/scala/concurrent/ops.scala
+++ b/src/library/scala/concurrent/ops.scala
@@ -39,18 +39,23 @@ object ops
     runner execute runner.functionAsTask(() => p)
   }
 
-  /**
-   *  @param p ...
-   *  @return  ...
+  /** Evaluates an expression asynchronously, and returns a closure for retrieving
+   *  the result.
+   *
+   *  @param  p the expression to evaluate
+   *  @return   a closure which returns the result once it has been computed
    */
   def future[A](p: => A)(implicit runner: FutureTaskRunner = defaultRunner): () => A = {
     runner.futureAsFunction(runner submit runner.functionAsTask(() => p))
   }
 
-  /**
-   *  @param xp ...
-   *  @param yp ...
-   *  @return   ...
+  /** Evaluates two expressions in parallel. Invoking `par' blocks the current
+   *  thread until both expressions have been evaluated.
+   *
+   *  @param  xp the first expression to evaluate
+   *  @param  yp the second expression to evaluate
+   *
+   *  @return    a pair holding the evaluation results
    */
   def par[A, B](xp: => A, yp: => B): (A, B) = {
     val y = new SyncVar[Either[Throwable, B]]
@@ -63,6 +68,7 @@ object ops
    *  @param end   ...
    *  @param p     ...
    */
+  @deprecated("use `collection.parallel.ParIterable.foreach' instead")
   def replicate(start: Int, end: Int)(p: Int => Unit) {
     if (start == end)
       ()
diff --git a/src/library/scala/concurrent/pilib.scala b/src/library/scala/concurrent/pilib.scala
index 3c3b280e14..a81df2d622 100644
--- a/src/library/scala/concurrent/pilib.scala
+++ b/src/library/scala/concurrent/pilib.scala
@@ -29,6 +29,7 @@ package scala.concurrent
  *  @author  Vincent Cremet, Martin Odersky
  *  @version 1.0
  */
+@deprecated("use actors instead")
 object pilib {
 
   import TaskRunners.threadRunner