Renaming Future.or to fallbackTo

akka-actor-tests/src/test/scala/akka/dispatch/FutureSpec.scala

@@ -55,11 +55,11 @@ class FutureSpec extends AkkaSpec with Checkers with BeforeAndAfterAll with Defa
         val empty = Promise[String]()
         val timedOut = Promise.successful[String]("Timedout")
 
-        Await.result(failure or timedOut, timeout.duration) must be("Timedout")
+        Await.result(failure fallbackTo timedOut, timeout.duration) must be("Timedout")
-        Await.result(timedOut or empty, timeout.duration) must be("Timedout")
+        Await.result(timedOut fallbackTo empty, timeout.duration) must be("Timedout")
-        Await.result(failure or failure or timedOut, timeout.duration) must be("Timedout")
+        Await.result(failure fallbackTo failure fallbackTo timedOut, timeout.duration) must be("Timedout")
         intercept[RuntimeException] {
-          Await.result(failure or otherFailure, timeout.duration)
+          Await.result(failure fallbackTo otherFailure, timeout.duration)
         }.getMessage must be("last")
       }
     }

akka-actor/src/main/scala/akka/dispatch/Future.scala

@@ -442,7 +442,7 @@ sealed trait Future[+T] extends japi.Future[T] with Await.Awaitable[T] {
    * Returns a new Future that will either hold the successful value of this Future,
    * or, it this Future fails, it will hold the result of "that" Future.
    */
-  def or[U >: T](that: Future[U]): Future[U] = {
+  def fallbackTo[U >: T](that: Future[U]): Future[U] = {
     val p = Promise[U]()
     onComplete {
       case r @ Right(_) ⇒ p complete r

akka-docs/java/code/akka/docs/future/FutureDocTestBase.java

@@ -382,7 +382,7 @@ public class FutureDocTestBase {
     }
 
     {
-        //#or
+        //#fallback-to
         Future<String> future1 =
                 Futures.failed(new IllegalStateException("OHNOES1"), system.dispatcher());
         Future<String> future2 =
@@ -390,10 +390,10 @@ public class FutureDocTestBase {
         Future<String> future3 =
                 Futures.successful("bar", system.dispatcher());
         Future<String> future4 =
-                future1.or(future2).or(future3); // Will have "bar" in this case
+                future1.fallbackTo(future2).fallbackTo(future3); // Will have "bar" in this case
         String result = Await.result(future4,  Duration.create(1, SECONDS));
         assertEquals("bar", result);
-        //#or
+        //#fallback-to
     }
 
   }

akka-docs/java/futures.rst

@@ -179,11 +179,11 @@ For this Akka supports ``onComplete``, ``onSuccess`` and ``onFailure``, of which
 Auxiliary methods
 -----------------
 
-``Future`` ``or`` combines 2 Futures into a new ``Future``, and will hold the successful value of the second ``Future`
+``Future`` ``fallbackTo`` combines 2 Futures into a new ``Future``, and will hold the successful value of the second ``Future`
 if the first ``Future`` fails.
 
 .. includecode:: code/akka/docs/future/FutureDocTestBase.java
-   :include: or
+   :include: fallback-to
 
 You can also combine two Futures into a new ``Future`` that will hold a tuple of the two Futures successful results,
 using the ``zip`` operation.

akka-docs/scala/code/akka/docs/future/FutureDocSpec.scala

@@ -275,13 +275,13 @@ class FutureDocSpec extends AkkaSpec {
     Await.result(future3, 1 second) must be("foo bar")
   }
 
-  "demonstrate usage of or" in {
+  "demonstrate usage of fallbackTo" in {
     val future1 = Future { "foo" }
     val future2 = Future { "bar" }
     val future3 = Future { "pigdog" }
-    //#or
+    //#fallback-to
-    val future4 = future1 or future2 or future3
+    val future4 = future1 fallbackTo future2 fallbackTo future3
-    //#or
+    //#fallback-to
     Await.result(future4, 1 second) must be("foo")
   }
 

akka-docs/scala/futures.rst

@@ -201,11 +201,11 @@ For this Akka supports ``onComplete``, ``onSuccess`` and ``onFailure``, of which
 Auxiliary methods
 -----------------
 
-``Future`` ``or`` combines 2 Futures into a new ``Future``, and will hold the successful value of the second ``Future`
+``Future`` ``fallbackTo`` combines 2 Futures into a new ``Future``, and will hold the successful value of the second ``Future`
 if the first ``Future`` fails.
 
 .. includecode:: code/akka/docs/future/FutureDocSpec.scala
-   :include: or
+   :include: fallback-to
 
 You can also combine two Futures into a new ``Future`` that will hold a tuple of the two Futures successful results,
 using the ``zip`` operation.