Swapped some Eithers around to try to get every...

Swapped some Eithers around to try to get everyone in line with the
convention, which is failure in Left, success in Right.

5 files changed, 19 insertions, 24 deletions

diff --git a/src/library/scala/concurrent/JavaConversions.scala b/src/library/scala/concurrent/JavaConversions.scala
index 9fde489ced..7ee9096127 100644
--- a/src/library/scala/concurrent/JavaConversions.scala
+++ b/src/library/scala/concurrent/JavaConversions.scala
@@ -22,15 +22,12 @@ object JavaConversions {
       type Future[+R] = () => R
 
       def submit(task: () => Unit): this.Future[Unit] = {
-        val result = new SyncVar[Either[Unit, Throwable]]
+        val result = new SyncVar[Either[Throwable, Unit]]
         val runnable = new Runnable {
           def run() { result set tryCatch(task()) }
         }
         exec.execute(runnable)
-        () => result.get match {
-          case Left(a) => a
-          case Right(t) => throw t
-        }
+        () => ops getOrThrow result.get
       }
 
       def managedBlock(blocker: ManagedBlocker) {
diff --git a/src/library/scala/concurrent/TaskRunner.scala b/src/library/scala/concurrent/TaskRunner.scala
index d29e8ff12f..a393b065fa 100644
--- a/src/library/scala/concurrent/TaskRunner.scala
+++ b/src/library/scala/concurrent/TaskRunner.scala
@@ -15,15 +15,9 @@ trait TaskRunner[T] extends AsyncInvokable[() => T, T] {
 
   def managedBlock(blocker: ManagedBlocker): Unit
 
-  /** If expression computed successfully return it in <code>Left</code>,
-   *  otherwise return exception in <code>Right</code>.
+  /** If expression computed successfully return it in <code>Right</code>,
+   *  otherwise return exception in <code>Left</code>.
    */
-  protected def tryCatch[A](left: => A): Either[A, Exception] = {
-    try {
-      Left(left)
-    } catch {
-      case e: Exception => Right(e)
-    }
-  }
-
+  protected def tryCatch[A](body: => A): Either[Exception, A] =
+    ops tryCatchEx body
 }
diff --git a/src/library/scala/concurrent/ThreadRunner.scala b/src/library/scala/concurrent/ThreadRunner.scala
index 7fb653a326..f48e0384b7 100644
--- a/src/library/scala/concurrent/ThreadRunner.scala
+++ b/src/library/scala/concurrent/ThreadRunner.scala
@@ -11,15 +11,12 @@ class ThreadRunner[T] extends TaskRunner[T] {
   type Future[+S] = () => S
 
   def submit(task: () => T): this.Future[T] = {
-    val result = new SyncVar[Either[T, Exception]]
+    val result = new SyncVar[Either[Exception, T]]
     val runnable = new Runnable {
       def run() { result set tryCatch(task()) }
     }
     (new Thread(runnable)).start()
-    () => result.get match {
-      case Left(a) => a
-      case Right(t) => throw t
-    }
+    () => ops getOrThrow result.get
   }
 
   def managedBlock(blocker: ManagedBlocker) {
diff --git a/src/library/scala/concurrent/ops.scala b/src/library/scala/concurrent/ops.scala
index 182756dcb1..e2fb8f0ceb 100644
--- a/src/library/scala/concurrent/ops.scala
+++ b/src/library/scala/concurrent/ops.scala
@@ -18,8 +18,8 @@ import scala.util.control.Exception.allCatch
  *
  *  @author  Martin Odersky, Stepan Koltsov, Philipp Haller
  */
-object ops {
-
+object ops
+{
   implicit val defaultRunner: TaskRunner[Unit] =
     TaskRunners.threadRunner
 
@@ -27,10 +27,15 @@ object ops {
    *  If expression computed successfully return it in <code>Right</code>,
    *  otherwise return exception in <code>Left</code>.
    */
-  private def tryCatch[A](body: => A): Either[Throwable, A] =
+  def tryCatch[A](body: => A): Either[Throwable, A] =
     allCatch[A] either body
 
-  private def getOrThrow[A](x: Either[Throwable, A]): A =
+  def tryCatchEx[A](body: => A): Either[Exception, A] =
+    try Right(body) catch {
+      case ex: Exception  => Left(ex)
+    }
+
+  def getOrThrow[T <: Throwable, A](x: Either[T, A]): A =
     x.fold[A](throw _, identity _)
 
   /** Evaluates an expression asynchronously.
diff --git a/src/library/scala/reflect/RichClass.scala b/src/library/scala/reflect/RichClass.scala
index f016fb37dc..5d58d12377 100644
--- a/src/library/scala/reflect/RichClass.scala
+++ b/src/library/scala/reflect/RichClass.scala
@@ -10,6 +10,7 @@
 
 package scala.reflect
 
+import annotation.experimental
 import util.control.Exception._
 import util.ScalaClassLoader._
 import java.lang.{ Class => JClass }
@@ -22,6 +23,7 @@ object RichClass
   implicit def classWrapper[T](x: JClass[T]): RichClass[T] = new RichClass(x)
 }
 
+@experimental
 final class RichClass[T](val self: JClass[T]) extends Proxy
 {
   // The getConstructors and getDeclaredConstructors methods on java.lang.Class[T]