Fixed the build.

5 files changed, 41 insertions, 31 deletions

diff --git a/src/library/scala/concurrent/ExecutionContext.scala b/src/library/scala/concurrent/ExecutionContext.scala
index 9606c28bab..207e190e95 100644
--- a/src/library/scala/concurrent/ExecutionContext.scala
+++ b/src/library/scala/concurrent/ExecutionContext.scala
@@ -1,7 +1,7 @@
 package scala.concurrent
 
 
-import java.util.concurrent.{ Executors, Future => JFuture }
+import java.util.concurrent.{ Executors, Future => JFuture, Callable }
 import scala.util.{ Duration, Timeout }
 import scala.concurrent.forkjoin.{ ForkJoinPool, RecursiveTask => FJTask, RecursiveAction, ForkJoinWorkerThread }
 
@@ -10,17 +10,13 @@ trait ExecutionContext {
   
   protected implicit object CanBlockEvidence extends CanBlock
   
-  def execute(task: Runnable): Unit
-  
-  def task[T](task: => T): Task[T]
+  def execute(runnable: Runnable): Unit
   
   def promise[T]: Promise[T]
   
-  def future[T](body: => T): Future[T] = {
-    val t = task(body)
-    t.start()
-    t.future
-  }
+  def future[T](body: Callable[T]): Future[T] = future(body.call())
+  
+  def future[T](body: => T): Future[T]
 
   /** Only callable from the tasks running on the same execution context. */
   def blockingCall[T](body: Blockable[T]): T
@@ -28,7 +24,6 @@ trait ExecutionContext {
 }
 
 
-
 sealed trait CanBlock
 
 
diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala
index 0aa6731353..6c84ec7cd8 100644
--- a/src/library/scala/concurrent/Future.scala
+++ b/src/library/scala/concurrent/Future.scala
@@ -320,30 +320,31 @@ self =>
   
 }
 
+
 object Future {
   
-  def all[T,Coll[_] <: Traversable[_]](fs: Coll[Future[T]])(implicit cbf: CanBuildFrom[Coll[Future[T]],T,Coll[T]]): Future[Coll[T]] = {
-    val builder = cbf(fs)
+  def all[T, Coll[X] <: Traversable[X]](futures: Coll[Future[T]])(implicit cbf: CanBuildFrom[Coll[_], T, Coll[T]]): Future[Coll[T]] = {
+    val builder = cbf(futures)
     val p: Promise[Coll[T]] = executionContext.promise[Coll[T]]
     
-    if (fs.size == 1) fs.head onComplete {
+    if (futures.size == 1) futures.head onComplete {
       case Left(t) => p break t
       case Right(v) => builder += v
         p fulfill builder.result
     } else {
-      val restFutures = all(fs.tail)
-      fs.head onComplete {
+      val restFutures = all(futures.tail)
+      futures.head onComplete {
         case Left(t) => p break t
         case Right(v) => builder += v
-          restFuture onComplete {
+          restFutures onComplete {
             case Left(t) => p break t
             case Right(vs) => for (v <- vs) builder += v
               p fulfill builder.result
           }
       }
     }
+    
     p.future
-
   }
 
 }
diff --git a/src/library/scala/concurrent/Task.scala b/src/library/scala/concurrent/Task.scala
index 98c7da77d2..d6f86bac31 100644
--- a/src/library/scala/concurrent/Task.scala
+++ b/src/library/scala/concurrent/Task.scala
@@ -2,7 +2,7 @@ package scala.concurrent
 
 
 
-trait Task[T] {
+trait Task[+T] {
   
   def start(): Unit
   
diff --git a/src/library/scala/concurrent/default/TaskImpl.scala b/src/library/scala/concurrent/default/TaskImpl.scala
index ebb8f65ab6..ca88735266 100644
--- a/src/library/scala/concurrent/default/TaskImpl.scala
+++ b/src/library/scala/concurrent/default/TaskImpl.scala
@@ -248,6 +248,12 @@ private[concurrent] final class ExecutionContextImpl extends ExecutionContext {
     new TaskImpl(this, body)
   }
   
+  def future[T](body: => T): Future[T] = {
+    val t = task(body)
+    t.start()
+    t.future
+  }
+  
   def promise[T]: Promise[T] =
     null
   
diff --git a/src/library/scala/concurrent/package.scala b/src/library/scala/concurrent/package.scala
index 900e872b51..fed7f7caf8 100644
--- a/src/library/scala/concurrent/package.scala
+++ b/src/library/scala/concurrent/package.scala
@@ -23,11 +23,31 @@ package object concurrent {
   
   lazy val executionContext =
     new default.ExecutionContextImpl
-
+  
   private[concurrent] def currentExecutionContext: ThreadLocal[ExecutionContext] = new ThreadLocal[ExecutionContext] {
     override protected def initialValue = null
   }
   
+  val handledFutureException: PartialFunction[Throwable, Throwable] = {
+    case t: Throwable if isFutureThrowable(t) => t
+  }
+  
+  // TODO rename appropriately and make public
+  private[concurrent] def isFutureThrowable(t: Throwable) = t match {
+    case e: Error => false
+    case t: scala.util.control.ControlThrowable => false
+    case i: InterruptedException => false
+    case _ => true
+  }
+  
+  /* concurrency constructs */
+  
+  def future[T](body: =>T): Future[T] =
+    executionContext future body
+  
+  def promise[T]: Promise[T] =
+    executionContext promise
+  
   /** The keyword used to block on a piece of code which potentially blocks.
    *
    *  @define mayThrow
@@ -62,18 +82,6 @@ package object concurrent {
     }
   }
   
-  val handledFutureException: PartialFunction[Throwable, Throwable] = {
-    case t: Throwable if isFutureThrowable(t) => t
-  }
-  
-  // TODO rename appropriately and make public
-  private[concurrent] def isFutureThrowable(t: Throwable) = t match {
-    case e: Error => false
-    case t: scala.util.control.ControlThrowable => false
-    case i: InterruptedException => false
-    case _ => true
-  }
-  
 }