Fix all combinator on futures, refactor execution context, remove disabled files.

Author: aleksandar

src/library/scala/concurrent/AbstractPromise.java.disabled

@@ -11,14 +11,12 @@ package scala.concurrent
 
 
 import java.util.concurrent.{ Executors, Future => JFuture, Callable }
-import java.util.concurrent.atomic.{ AtomicInteger }
-import scala.util.{ Duration, Timeout }
+import scala.util.Duration
 import scala.concurrent.forkjoin.{ ForkJoinPool, RecursiveTask => FJTask, RecursiveAction, ForkJoinWorkerThread }
-import scala.collection.generic.CanBuildFrom
 
 
 
-trait ExecutionContext {
+trait ExecutionContext extends ExecutionContextBase {
 
   protected implicit object CanAwaitEvidence extends CanAwait
 
@@ -36,80 +34,10 @@ trait ExecutionContext {
 
   def blocking[T](awaitable: Awaitable[T], atMost: Duration): T
 
-  def futureUtilities: FutureUtilities = FutureUtilitiesImpl
-  
 }
 
 
 sealed trait CanAwait
 
 
-trait FutureUtilities {
-  
-/** TODO some docs
- *  
- */
-  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]] = promise[Coll[T]]
-    
-    if (futures.size == 1) futures.head onComplete {
-      case Left(t) => p failure t
-      case Right(v) => builder += v
-        p success builder.result
-    } else {
-      val restFutures = all(futures.tail)
-      futures.head onComplete {
-        case Left(t) => p failure t
-        case Right(v) => builder += v
-          restFutures onComplete {
-            case Left(t) => p failure t
-            case Right(vs) => for (v <- vs) builder += v
-              p success builder.result
-          }
-      }
-    }
-    
-    p.future
-  }
-
-/** TODO some docs
- *  
- */
-  def any[T](futures: Traversable[Future[T]]): Future[T] = {
-    val futureResult = promise[T]()
-    
-    val completeFirst: Either[Throwable, T] => Unit = futureElem => futureResult tryComplete futureElem
-
-    futures.foreach(_ onComplete completeFirst)
-
-    futureResult.future
-  }
-
-/** TODO some docs
- *  
- */
-  def find[T](futures: Traversable[Future[T]])(predicate: T => Boolean): Future[Option[T]] = {
-    if (futures.isEmpty) Promise.successful[Option[T]](None).future
-    else {
-      val result = promise[Option[T]]()
-      val ref = new AtomicInteger(futures.size)
-      val search: Either[Throwable, T] ⇒ Unit = { 
-        v ⇒ v match {
-          case Right(r) ⇒ if (predicate(r)) result trySuccess Some(r)
-          case _        ⇒
-        }
-        if (ref.decrementAndGet == 0) result trySuccess None
-      }
-
-      futures.foreach(_ onComplete search)
-
-      result.future
-    }
-  }
-
-}
-
-object FutureUtilitiesImpl extends FutureUtilities {
-}
 

src/library/scala/concurrent/ExecutionContext.scala

@@ -355,8 +355,7 @@ self =>
 
     p.future
   }
-
-/*  
+  
   /** Creates a new future which holds the result of either this future or `that` future, depending on
    *  which future was completed first.
    *  
@@ -370,20 +369,20 @@ self =>
    *  await(0) h // evaluates to either 5 or throws a runtime exception
    *  }}}
    */
-  def any[U >: T](that: Future[U]): Future[U] = {
+  def either[U >: T](that: Future[U]): Future[U] = {
     val p = newPromise[U]
 
-    val completePromise: PartialFunction[Either[Throwable, T], _] = {
+    val completePromise: PartialFunction[Either[Throwable, U], _] = {
       case Left(t) => p tryFailure t
       case Right(v) => p trySuccess v
     }
+    
     this onComplete completePromise
     that onComplete completePromise
 
     p.future
   }
-
-*/
+  
 }
 
 
@@ -399,14 +398,14 @@ object Future {
   /** TODO some docs
    */
   def all[T, Coll[X] <: Traversable[X]](futures: Coll[Future[T]])(implicit cbf: CanBuildFrom[Coll[_], T, Coll[T]], ec: ExecutionContext): Future[Coll[T]] =
-    ec.futureUtilities.all[T, Coll](futures)
+    ec.all[T, Coll](futures)
 
   // move this to future companion object
   @inline def apply[T](body: =>T)(implicit executor: ExecutionContext): Future[T] = executor.future(body)
 
-  def any[T](futures: Traversable[Future[T]])(implicit ec: ExecutionContext): Future[T] = ec.futureUtilities.any(futures)
+  def any[T](futures: Traversable[Future[T]])(implicit ec: ExecutionContext): Future[T] = ec.any(futures)
 
-  def find[T](futures: Traversable[Future[T]])(predicate: T => Boolean)(implicit ec: ExecutionContext): Future[Option[T]] = ec.futureUtilities.find(futures)(predicate)
+  def find[T](futures: Traversable[Future[T]])(predicate: T => Boolean)(implicit ec: ExecutionContext): Future[Option[T]] = ec.find(futures)(predicate)
 
 }