diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/library/scala/concurrent/ExecutionContext.scala | 11 | ||||
-rw-r--r-- | src/library/scala/concurrent/Future.scala | 72 | ||||
-rw-r--r-- | src/library/scala/concurrent/Promise.scala | 10 | ||||
-rw-r--r-- | src/library/scala/concurrent/akka/ExecutionContextImpl.scala | 4 | ||||
-rw-r--r-- | src/library/scala/concurrent/akka/Future.scala | 13 | ||||
-rw-r--r-- | src/library/scala/concurrent/akka/Promise.scala | 46 | ||||
-rw-r--r-- | src/library/scala/concurrent/default/TaskImpl.scala | 32 | ||||
-rw-r--r-- | src/library/scala/concurrent/package.scala | 27 | ||||
-rw-r--r-- | src/library/scala/util/Try.scala | 22 |
9 files changed, 122 insertions, 115 deletions
diff --git a/src/library/scala/concurrent/ExecutionContext.scala b/src/library/scala/concurrent/ExecutionContext.scala index 40fafd130c..99cd264ac5 100644 --- a/src/library/scala/concurrent/ExecutionContext.scala +++ b/src/library/scala/concurrent/ExecutionContext.scala @@ -13,6 +13,7 @@ package scala.concurrent import java.util.concurrent.atomic.{ AtomicInteger } import java.util.concurrent.{ Executors, Future => JFuture, Callable } import scala.util.Duration +import scala.util.{ Try, Success, Failure } import scala.concurrent.forkjoin.{ ForkJoinPool, RecursiveTask => FJTask, RecursiveAction, ForkJoinWorkerThread } import scala.collection.generic.CanBuildFrom import collection._ @@ -74,9 +75,9 @@ trait ExecutionContext { buffer += null.asInstanceOf[T] counter.incrementAndGet() f onComplete { - case Left(t) => + case Failure(t) => p tryFailure t - case Right(v) => + case Success(v) => buffer(currentIndex) = v tryFinish() } @@ -93,7 +94,7 @@ trait ExecutionContext { */ def any[T](futures: Traversable[Future[T]]): Future[T] = { val p = promise[T] - val completeFirst: Either[Throwable, T] => Unit = elem => p tryComplete elem + val completeFirst: Try[T] => Unit = elem => p tryComplete elem futures foreach (_ onComplete completeFirst) @@ -108,9 +109,9 @@ trait ExecutionContext { else { val result = promise[Option[T]] val count = new AtomicInteger(futures.size) - val search: Either[Throwable, T] => Unit = { + val search: Try[T] => Unit = { v => v match { - case Right(r) => if (predicate(r)) result trySuccess Some(r) + case Success(r) => if (predicate(r)) result trySuccess Some(r) case _ => } if (count.decrementAndGet() == 0) result trySuccess None diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala index 8d69586fbc..c87c51c0df 100644 --- a/src/library/scala/concurrent/Future.scala +++ b/src/library/scala/concurrent/Future.scala @@ -17,7 +17,7 @@ import java.util.{ LinkedList => JLinkedList } import java.{ lang => jl } import java.util.concurrent.atomic.{ AtomicReferenceFieldUpdater, AtomicInteger, AtomicBoolean } -import scala.util.{ Timeout, Duration } +import scala.util.{ Timeout, Duration, Try, Success, Failure } import scala.Option import scala.annotation.tailrec @@ -96,8 +96,8 @@ self => * $multipleCallbacks */ def onSuccess[U](pf: PartialFunction[T, U]): this.type = onComplete { - case Left(t) => // do nothing - case Right(v) if pf isDefinedAt v => pf(v) + case Failure(t) => // do nothing + case Success(v) => if (pf isDefinedAt v) pf(v) else { /*do nothing*/ } } /** When this future is completed with a failure (i.e. with a throwable), @@ -113,8 +113,8 @@ self => * $multipleCallbacks */ def onFailure[U](callback: PartialFunction[Throwable, U]): this.type = onComplete { - case Left(t) if isFutureThrowable(t) => if (callback.isDefinedAt(t)) callback(t) - case Right(v) => // do nothing + case Failure(t) => if (isFutureThrowable(t) && callback.isDefinedAt(t)) callback(t) else { /*do nothing*/ } + case Success(v) => // do nothing } /** When this future is completed, either through an exception, a timeout, or a value, @@ -125,7 +125,7 @@ self => * * $multipleCallbacks */ - def onComplete[U](func: Either[Throwable, T] => U): this.type + def onComplete[U](func: Try[T] => U): this.type /* Miscellaneous */ @@ -156,8 +156,8 @@ self => val p = newPromise[Throwable] onComplete { - case Left(t) => p success t - case Right(v) => p failure noSuchElem(v) + case Failure(t) => p success t + case Success(v) => p failure noSuchElem(v) } p.future @@ -171,8 +171,8 @@ self => * Will not be called if the future fails. */ def foreach[U](f: T => U): Unit = onComplete { - case Right(r) => f(r) - case Left(_) => // do nothing + case Success(r) => f(r) + case Failure(_) => // do nothing } /** Creates a new future by applying a function to the successful result of @@ -185,8 +185,8 @@ self => val p = newPromise[S] onComplete { - case Left(t) => p failure t - case Right(v) => + case Failure(t) => p failure t + case Success(v) => try p success f(v) catch { case t => p complete resolver(t) @@ -207,12 +207,12 @@ self => val p = newPromise[S] onComplete { - case Left(t) => p failure t - case Right(v) => + case Failure(t) => p failure t + case Success(v) => try { f(v) onComplete { - case Left(t) => p failure t - case Right(v) => p success v + case Failure(t) => p failure t + case Success(v) => p success v } } catch { case t: Throwable => p complete resolver(t) @@ -242,8 +242,8 @@ self => val p = newPromise[T] onComplete { - case Left(t) => p failure t - case Right(v) => + case Failure(t) => p failure t + case Success(v) => try { if (pred(v)) p success v else p failure new NoSuchElementException("Future.filter predicate is not satisfied by: " + v) @@ -279,8 +279,8 @@ self => val p = newPromise[S] onComplete { - case Left(t) => p failure t - case Right(v) => + case Failure(t) => p failure t + case Success(v) => try { if (pf.isDefinedAt(v)) p success pf(v) else p failure new NoSuchElementException("Future.collect partial function is not defined at: " + v) @@ -308,7 +308,7 @@ self => val p = newPromise[U] onComplete { - case Left(t) if pf isDefinedAt t => + case Failure(t) if pf isDefinedAt t => try { p success pf(t) } catch { case t: Throwable => p complete resolver(t) } case otherwise => p complete otherwise @@ -334,11 +334,11 @@ self => val p = newPromise[U] onComplete { - case Left(t) if pf isDefinedAt t => + case Failure(t) if pf isDefinedAt t => try { pf(t) onComplete { - case Left(t) => p failure t - case Right(v) => p success v + case Failure(t) => p failure t + case Success(v) => p success v } } catch { case t: Throwable => p complete resolver(t) @@ -361,8 +361,8 @@ self => val p = newPromise[(T, U)] this onComplete { - case Left(t) => p failure t - case Right(r) => that onSuccess { + case Failure(t) => p failure t + case Success(r) => that onSuccess { case r2 => p success ((r, r2)) } } @@ -392,11 +392,11 @@ self => val p = newPromise[U] onComplete { - case Left(t) => that onComplete { - case Left(_) => p failure t - case Right(v) => p success v + case Failure(t) => that onComplete { + case Failure(_) => p failure t + case Success(v) => p success v } - case Right(v) => p success v + case Success(v) => p success v } p.future @@ -420,12 +420,12 @@ self => * f andThen { * case r => sys.error("runtime exception") * } andThen { - * case Left(t) => println(t) - * case Right(v) => println(v) + * case Failure(t) => println(t) + * case Success(v) => println(v) * } * }}} */ - def andThen[U](pf: PartialFunction[Either[Throwable, T], U]): Future[T] = { + def andThen[U](pf: PartialFunction[Try[T], U]): Future[T] = { val p = newPromise[T] onComplete { @@ -453,9 +453,9 @@ self => def either[U >: T](that: Future[U]): Future[U] = { val p = self.newPromise[U] - val completePromise: PartialFunction[Either[Throwable, U], _] = { - case Left(t) => p tryFailure t - case Right(v) => p trySuccess v + val completePromise: PartialFunction[Try[U], _] = { + case Failure(t) => p tryFailure t + case Success(v) => p trySuccess v } self onComplete completePromise diff --git a/src/library/scala/concurrent/Promise.scala b/src/library/scala/concurrent/Promise.scala index acc02fba5f..f26deb77ab 100644 --- a/src/library/scala/concurrent/Promise.scala +++ b/src/library/scala/concurrent/Promise.scala @@ -8,7 +8,7 @@ package scala.concurrent - +import scala.util.{ Try, Success, Failure } @@ -42,7 +42,7 @@ trait Promise[T] { * * $promiseCompletion */ - def complete(result: Either[Throwable, T]): this.type = if (tryComplete(result)) this else throwCompleted + def complete(result:Try[T]): this.type = if (tryComplete(result)) this else throwCompleted /** Tries to complete the promise with either a value or the exception. * @@ -50,7 +50,7 @@ trait Promise[T] { * * @return If the promise has already been completed returns `false`, or `true` otherwise. */ - def tryComplete(result: Either[Throwable, T]): Boolean + def tryComplete(result: Try[T]): Boolean /** Completes this promise with the specified future, once that future is completed. * @@ -77,7 +77,7 @@ trait Promise[T] { * * @return If the promise has already been completed returns `false`, or `true` otherwise. */ - def trySuccess(value: T): Boolean = tryComplete(Right(value)) + def trySuccess(value: T): Boolean = tryComplete(Success(value)) /** Completes the promise with an exception. * @@ -95,7 +95,7 @@ trait Promise[T] { * * @return If the promise has already been completed returns `false`, or `true` otherwise. */ - def tryFailure(t: Throwable): Boolean = tryComplete(Left(t)) + def tryFailure(t: Throwable): Boolean = tryComplete(Failure(t)) /** Wraps a `Throwable` in an `ExecutionException` if necessary. TODO replace with `resolver` from scala.concurrent * diff --git a/src/library/scala/concurrent/akka/ExecutionContextImpl.scala b/src/library/scala/concurrent/akka/ExecutionContextImpl.scala index e2773e1fd5..f8c99d857b 100644 --- a/src/library/scala/concurrent/akka/ExecutionContextImpl.scala +++ b/src/library/scala/concurrent/akka/ExecutionContextImpl.scala @@ -12,7 +12,7 @@ package scala.concurrent.akka import java.util.concurrent.{Callable, ExecutorService} import scala.concurrent.{ExecutionContext, resolver, Awaitable, body2awaitable} -import scala.util.Duration +import scala.util.{ Duration, Try, Success, Failure } import scala.collection.mutable.Stack @@ -41,7 +41,7 @@ class ExecutionContextImpl(executorService: ExecutorService) extends ExecutionCo () => p complete { try { - Right(body) + Success(body) } catch { case e => resolver(e) } diff --git a/src/library/scala/concurrent/akka/Future.scala b/src/library/scala/concurrent/akka/Future.scala index be1a9ec2ae..2633e751bd 100644 --- a/src/library/scala/concurrent/akka/Future.scala +++ b/src/library/scala/concurrent/akka/Future.scala @@ -11,6 +11,7 @@ package scala.concurrent.akka import scala.concurrent.{Awaitable, ExecutionContext} +import scala.util.{ Try, Success, Failure } //import scala.util.continuations._ @@ -35,9 +36,9 @@ trait Future[+T] extends scala.concurrent.Future[T] with Awaitable[T] { * if it contains a valid result, or Some(Left(error)) if it contains * an exception. */ - def value: Option[Either[Throwable, T]] + def value: Option[Try[T]] - def onComplete[U](func: Either[Throwable, T] => U): this.type + 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. @@ -46,12 +47,12 @@ trait Future[+T] extends scala.concurrent.Future[T] with Awaitable[T] { val p = executor.promise[T] onComplete { - case l @ Left(t) => p complete l.asInstanceOf[Either[Throwable, T]] - case Right(v) => + case f @ Failure(t) => p complete f.asInstanceOf[Try[T]] + case Success(v) => p complete (try { - Right(boxedType(m.erasure).cast(v).asInstanceOf[T]) + Success(boxedType(m.erasure).cast(v).asInstanceOf[T]) } catch { - case e: ClassCastException ⇒ Left(e) + case e: ClassCastException ⇒ Failure(e) }) } diff --git a/src/library/scala/concurrent/akka/Promise.scala b/src/library/scala/concurrent/akka/Promise.scala index fad78478a5..8ecffec2aa 100644 --- a/src/library/scala/concurrent/akka/Promise.scala +++ b/src/library/scala/concurrent/akka/Promise.scala @@ -15,8 +15,10 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater import scala.concurrent.{Awaitable, ExecutionContext, resolve, resolver, blocking, CanAwait, TimeoutException} //import scala.util.continuations._ import scala.util.Duration +import scala.util.Try +import scala.util import scala.annotation.tailrec -import scala.concurrent.NonDeterministic +//import scala.concurrent.NonDeterministic trait Promise[T] extends scala.concurrent.Promise[T] with Future[T] { @@ -77,18 +79,18 @@ object Promise { /** Represents the internal state. */ - sealed trait FState[+T] { def value: Option[Either[Throwable, T]] } + sealed trait FState[+T] { def value: Option[Try[T]] } - case class Pending[T](listeners: List[Either[Throwable, T] => Any] = Nil) extends FState[T] { - def value: Option[Either[Throwable, T]] = None + case class Pending[T](listeners: List[Try[T] => Any] = Nil) extends FState[T] { + def value: Option[Try[T]] = None } - case class Success[T](value: Option[Either[Throwable, T]] = None) extends FState[T] { - def result: T = value.get.right.get + case class Success[T](value: Option[util.Success[T]] = None) extends FState[T] { + def result: T = value.get.get } - case class Failure[T](value: Option[Either[Throwable, T]] = None) extends FState[T] { - def exception: Throwable = value.get.left.get + case class Failure[T](value: Option[util.Failure[T]] = None) extends FState[T] { + def exception: Throwable = value.get.exception } private val emptyPendingValue = Pending[Nothing](Nil) @@ -129,11 +131,11 @@ object Promise { def await(atMost: Duration)(implicit permit: CanAwait): T = ready(atMost).value.get match { - case Left(e) => throw e - case Right(r) => r + case util.Failure(e) => throw e + case util.Success(r) => r } - def value: Option[Either[Throwable, T]] = getState.value + def value: Option[Try[T]] = getState.value @inline private[this] final def updater = AbstractPromise.updater.asInstanceOf[AtomicReferenceFieldUpdater[AbstractPromise, FState[T]]] @@ -144,14 +146,14 @@ object Promise { @inline protected final def getState: FState[T] = updater.get(this) - def tryComplete(value: Either[Throwable, T]): Boolean = { - val callbacks: List[Either[Throwable, T] => Any] = { + def tryComplete(value: Try[T]): Boolean = { + val callbacks: List[Try[T] => Any] = { try { @tailrec - def tryComplete(v: Either[Throwable, T]): List[Either[Throwable, T] => Any] = { + def tryComplete(v: Try[T]): List[Try[T] => Any] = { getState match { case cur @ Pending(listeners) => - if (updateState(cur, if (v.isLeft) Failure(Some(v)) else Success(Some(v)))) listeners + if (updateState(cur, if (v.isFailure) Failure(Some(v.asInstanceOf[util.Failure[T]])) else Success(Some(v.asInstanceOf[util.Success[T]])))) listeners else tryComplete(v) case _ => null } @@ -173,7 +175,7 @@ object Promise { } } - def onComplete[U](func: Either[Throwable, T] => U): this.type = { + def onComplete[U](func: Try[T] => U): this.type = { @tailrec // Returns whether the future has already been completed or not def tryAddCallback(): Boolean = { val cur = getState @@ -195,7 +197,7 @@ object Promise { this } - private final def notifyCompleted(func: Either[Throwable, T] => Any, result: Either[Throwable, T]) { + private final def notifyCompleted(func: Try[T] => Any, result: Try[T]) { try { func(result) } catch { @@ -208,12 +210,12 @@ object Promise { * * Useful in Future-composition when a value to contribute is already available. */ - final class KeptPromise[T](suppliedValue: Either[Throwable, T])(implicit val executor: ExecutionContextImpl) extends Promise[T] { + final class KeptPromise[T](suppliedValue: Try[T])(implicit val executor: ExecutionContextImpl) extends Promise[T] { val value = Some(resolve(suppliedValue)) - def tryComplete(value: Either[Throwable, T]): Boolean = false + def tryComplete(value: Try[T]): Boolean = false - def onComplete[U](func: Either[Throwable, T] => U): this.type = { + def onComplete[U](func: Try[T] => U): this.type = { val completedAs = value.get executor dispatchFuture { () => func(completedAs) @@ -224,8 +226,8 @@ object Promise { private def ready(atMost: Duration)(implicit permit: CanAwait): this.type = this def await(atMost: Duration)(implicit permit: CanAwait): T = value.get match { - case Left(e) => throw e - case Right(r) => r + case util.Failure(e) => throw e + case util.Success(r) => r } } diff --git a/src/library/scala/concurrent/default/TaskImpl.scala b/src/library/scala/concurrent/default/TaskImpl.scala index 7ac297de9e..94e54cb372 100644 --- a/src/library/scala/concurrent/default/TaskImpl.scala +++ b/src/library/scala/concurrent/default/TaskImpl.scala @@ -5,6 +5,8 @@ package default import java.util.concurrent.atomic.AtomicReferenceFieldUpdater import scala.concurrent.forkjoin.{ ForkJoinPool, RecursiveAction, ForkJoinWorkerThread } +import scala.util.Try +import scala.util import scala.util.Duration import scala.annotation.tailrec @@ -17,7 +19,7 @@ self: Future[T] => def newPromise[S]: Promise[S] = executor promise - type Callback = Either[Throwable, T] => Any + type Callback = Try[T] => Any def getState: State[T] @@ -25,22 +27,22 @@ self: Future[T] => protected def dispatch[U](r: Runnable) = executionContext execute r - protected def processCallbacks(cbs: List[Callback], r: Either[Throwable, T]) = + protected def processCallbacks(cbs: List[Callback], r: Try[T]) = for (cb <- cbs) dispatch(new Runnable { override def run() = cb(r) }) def future: Future[T] = self - def onComplete[U](callback: Either[Throwable, T] => U): this.type = { - @tailrec def tryAddCallback(): Either[Throwable, T] = { + def onComplete[U](callback: Try[T] => U): this.type = { + @tailrec def tryAddCallback(): Try[T] = { getState match { case p @ Pending(lst) => val pt = p.asInstanceOf[Pending[T]] if (casState(pt, Pending(callback :: pt.callbacks))) null else tryAddCallback() - case Success(res) => Right(res) - case Failure(t) => Left(t) + case Success(res) => util.Success(res) + case Failure(t) => util.Failure(t) } } @@ -87,9 +89,9 @@ extends Promise[T] with Future[T] with Completable[T] { case _ => null } - def tryComplete(r: Either[Throwable, T]) = r match { - case Left(t) => tryFailure(t) - case Right(v) => trySuccess(v) + def tryComplete(r: Try[T]) = r match { + case util.Failure(t) => tryFailure(t) + case util.Success(v) => trySuccess(v) } override def trySuccess(value: T): Boolean = { @@ -97,7 +99,7 @@ extends Promise[T] with Future[T] with Completable[T] { if (cbs == null) false else { - processCallbacks(cbs, Right(value)) + processCallbacks(cbs, util.Success(value)) this.synchronized { this.notifyAll() } @@ -111,7 +113,7 @@ extends Promise[T] with Future[T] with Completable[T] { if (cbs == null) false else { - processCallbacks(cbs, Left(wrapped)) + processCallbacks(cbs, util.Failure(wrapped)) this.synchronized { this.notifyAll() } @@ -163,13 +165,13 @@ extends RecursiveAction with Task[T] with Future[T] with Completable[T] { var cbs: List[Callback] = null try { val res = body - processCallbacks(tryCompleteState(Success(res)), Right(res)) + processCallbacks(tryCompleteState(Success(res)), util.Success(res)) } catch { case t if isFutureThrowable(t) => - processCallbacks(tryCompleteState(Failure(t)), Left(t)) + processCallbacks(tryCompleteState(Failure(t)), util.Failure(t)) case t => val ee = new ExecutionException(t) - processCallbacks(tryCompleteState(Failure(ee)), Left(ee)) + processCallbacks(tryCompleteState(Failure(ee)), util.Failure(ee)) throw t } } @@ -207,7 +209,7 @@ extends RecursiveAction with Task[T] with Future[T] with Completable[T] { private[concurrent] sealed abstract class State[T] -case class Pending[T](callbacks: List[Either[Throwable, T] => Any]) extends State[T] +case class Pending[T](callbacks: List[Try[T] => Any]) extends State[T] case class Success[T](result: T) extends State[T] diff --git a/src/library/scala/concurrent/package.scala b/src/library/scala/concurrent/package.scala index 5c3f1f818d..35b8cf6664 100644 --- a/src/library/scala/concurrent/package.scala +++ b/src/library/scala/concurrent/package.scala @@ -10,7 +10,7 @@ package scala -import scala.util.Duration +import scala.util.{ Duration, Try, Success, Failure } @@ -44,23 +44,24 @@ package object concurrent { case _ => true } - private[concurrent] def resolve[T](source: Either[Throwable, T]): Either[Throwable, T] = source match { - case Left(t: scala.runtime.NonLocalReturnControl[_]) => Right(t.value.asInstanceOf[T]) - case Left(t: scala.util.control.ControlThrowable) => Left(new ExecutionException("Boxed ControlThrowable", t)) - case Left(t: InterruptedException) => Left(new ExecutionException("Boxed InterruptedException", t)) - case Left(e: Error) => Left(new ExecutionException("Boxed Error", e)) + private[concurrent] def resolve[T](source: Try[T]): Try[T] = source match { + case Failure(t: scala.runtime.NonLocalReturnControl[_]) => Success(t.value.asInstanceOf[T]) + case Failure(t: scala.util.control.ControlThrowable) => Failure(new ExecutionException("Boxed ControlThrowable", t)) + case Failure(t: InterruptedException) => Failure(new ExecutionException("Boxed InterruptedException", t)) + case Failure(e: Error) => Failure(new ExecutionException("Boxed Error", e)) case _ => source } - private val resolverFunction: PartialFunction[Throwable, Either[Throwable, _]] = { - case t: scala.runtime.NonLocalReturnControl[_] => Right(t.value) - case t: scala.util.control.ControlThrowable => Left(new ExecutionException("Boxed ControlThrowable", t)) - case t: InterruptedException => Left(new ExecutionException("Boxed InterruptedException", t)) - case e: Error => Left(new ExecutionException("Boxed Error", e)) - case t => Left(t) + // TODO, docs, return type + private val resolverFunction: PartialFunction[Throwable, Try[_]] = { + case t: scala.runtime.NonLocalReturnControl[_] => Success(t.value) + case t: scala.util.control.ControlThrowable => Failure(new ExecutionException("Boxed ControlThrowable", t)) + case t: InterruptedException => Failure(new ExecutionException("Boxed InterruptedException", t)) + case e: Error => Failure(new ExecutionException("Boxed Error", e)) + case t => Failure(t) } - private[concurrent] def resolver[T] = resolverFunction.asInstanceOf[PartialFunction[Throwable, Either[Throwable, T]]] + private[concurrent] def resolver[T] = resolverFunction.asInstanceOf[PartialFunction[Throwable, Try[T]]] /* concurrency constructs */ diff --git a/src/library/scala/util/Try.scala b/src/library/scala/util/Try.scala index b82570cd05..a05a75e0b7 100644 --- a/src/library/scala/util/Try.scala +++ b/src/library/scala/util/Try.scala @@ -66,7 +66,7 @@ sealed abstract class Try[+T] { /** * Converts this to a `Failure` if the predicate is not satisfied. */ - def filterNote(p: T => Boolean): Try[T] = filter(x => !p(x)) + def filterNot(p: T => Boolean): Try[T] = filter(x => !p(x)) /** * Calls the exceptionHandler with the exception if this is a `Failure`. This is like `flatMap` for the exception. @@ -101,31 +101,31 @@ sealed abstract class Try[+T] { } -final case class Failure[+T](e: Throwable) extends Try[T] { +final case class Failure[+T](val exception: Throwable) extends Try[T] { def isFailure = true def isSuccess = false def rescue[U >: T](rescueException: PartialFunction[Throwable, Try[U]]): Try[U] = { try { - if (rescueException.isDefinedAt(e)) rescueException(e) else this + if (rescueException.isDefinedAt(exception)) rescueException(exception) else this } catch { case e2 => Failure(e2) } } - def get: T = throw e - def flatMap[U](f: T => Try[U]): Try[U] = Failure[U](e) - def flatten[U](implicit ev: T <:< Try[U]): Try[U] = Failure[U](e) + def get: T = throw exception + def flatMap[U](f: T => Try[U]): Try[U] = Failure[U](exception) + def flatten[U](implicit ev: T <:< Try[U]): Try[U] = Failure[U](exception) def foreach[U](f: T => U): Unit = {} - def map[U](f: T => U): Try[U] = Failure[U](e) - def collect[U](pf: PartialFunction[T, U]): Try[U] = Failure[U](e) + def map[U](f: T => U): Try[U] = Failure[U](exception) + def collect[U](pf: PartialFunction[T, U]): Try[U] = Failure[U](exception) def filter(p: T => Boolean): Try[T] = this def recover[U >: T](rescueException: PartialFunction[Throwable, U]): Try[U] = - if (rescueException.isDefinedAt(e)) { - Try(rescueException(e)) + if (rescueException.isDefinedAt(exception)) { + Try(rescueException(exception)) } else { this } def exists(p: T => Boolean): Boolean = false - def failed: Try[Throwable] = Success(e) + def failed: Try[Throwable] = Success(exception) } |