From 7c84f1fc32e99a309f9b47b7359764aecbfc21e6 Mon Sep 17 00:00:00 2001
From: Aleksandar Prokopec <axel22@gmail.com>
Date: Thu, 29 Mar 2012 17:52:08 +0200
Subject: Add withFilter and mapTo to futures.

---
 src/library/scala/concurrent/Future.scala      | 33 +++++++++++++++++++++++++-
 src/library/scala/concurrent/impl/Future.scala | 30 -----------------------
 2 files changed, 32 insertions(+), 31 deletions(-)

(limited to 'src')

diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala
index d73801aa90..8cecadc605 100644
--- a/src/library/scala/concurrent/Future.scala
+++ b/src/library/scala/concurrent/Future.scala
@@ -274,6 +274,18 @@ self =>
     p.future
   }
 
+  /** Used by for-comprehensions.
+   */
+  final def withFilter(p: T => Boolean): Future[T] = filter(p)
+  // final def withFilter(p: T => Boolean) = new FutureWithFilter[T](this, p)
+
+  // final class FutureWithFilter[+S](self: Future[S], p: S => Boolean) {
+  //   def foreach(f: S => Unit): Unit = self filter p foreach f
+  //   def map[R](f: S => R) = self filter p map f
+  //   def flatMap[R](f: S => Future[R]) = self filter p flatMap f
+  //   def withFilter(q: S => Boolean): FutureWithFilter[S] = new FutureWithFilter[S](self, x => p(x) && q(x))
+  // }
+
   /** Creates a new future by mapping the value of the current future if the given partial function is defined at that value.
    *
    *  If the current future contains a value for which the partial function is defined, the new future will also hold that value.
@@ -417,7 +429,26 @@ self =>
 
     p.future
   }
-
+  
+  /** Creates a new `Future[S]` which is completed with this `Future`'s result if
+   *  that conforms to `S`'s erased type or a `ClassCastException` otherwise.
+   */
+  def mapTo[S](implicit m: Manifest[S]): Future[S] = {
+    val p = newPromise[S]
+    
+    onComplete {
+      case l: Failure[_] => p complete l.asInstanceOf[Try[S]]
+      case Success(t) =>
+        p complete (try {
+          Success(impl.Future.boxedType(m.erasure).cast(t).asInstanceOf[S])
+        } catch {
+          case e: ClassCastException => Failure(e)
+        })
+    }
+    
+    p.future
+  }
+  
   /** Applies the side-effecting function to the result of this future, and returns
    *  a new future with the result of this future.
    *
diff --git a/src/library/scala/concurrent/impl/Future.scala b/src/library/scala/concurrent/impl/Future.scala
index 6833b2467f..1111aa4753 100644
--- a/src/library/scala/concurrent/impl/Future.scala
+++ b/src/library/scala/concurrent/impl/Future.scala
@@ -40,36 +40,6 @@ private[concurrent] trait Future[+T] extends scala.concurrent.Future[T] with Awa
 
   def onComplete[U](func: Try[T] => U): this.type
 
-  /** Creates a new Future[A] which is completed with this Future's result if
-   *  that conforms to A's erased type or a ClassCastException otherwise.
-   */
-  final def mapTo[T](implicit m: Manifest[T]) = {
-    val p = new Promise.DefaultPromise[T]
-
-    onComplete {
-      case f @ Failure(t) => p complete f.asInstanceOf[Try[T]]
-      case Success(v) =>
-        p complete (try {
-          Success(Future.boxedType(m.erasure).cast(v).asInstanceOf[T])
-        } catch {
-          case e: ClassCastException => Failure(e)
-        })
-    }
-
-    p.future
-  }
-
-  /** Used by for-comprehensions.
-   */
-  final def withFilter(p: T => Boolean) = new FutureWithFilter[T](this, p)
-
-  final class FutureWithFilter[+A](self: Future[A], p: A => Boolean) {
-    def foreach(f: A => Unit): Unit = self filter p foreach f
-    def map[B](f: A => B) = self filter p map f
-    def flatMap[B](f: A => Future[B]) = self filter p flatMap f
-    def withFilter(q: A => Boolean): FutureWithFilter[A] = new FutureWithFilter[A](self, x ⇒ p(x) && q(x))
-  }
-
 }
 
 object Future {
-- 
cgit v1.2.3