future

Is there a method in Akka (or in the standard library in Scala 2.10) to convert a Future[A] which might fail into a Future[Either[Exception,A]] ? I know that you can write f.map(Right(_)).recover { case e:Exception => Left(e) } It just seems to be such a common task that I wonder whether I have overlooked something. I'm interested in answers for Scala 2.9/Akka and Scala 2.10. The primary reason why this method is missing is that it does not really have good semantics: the static type Future[Either[Throwable, T]] does not ensure that that future cannot fail, hence the type change does not gain

I am trying to create a neat construction with for-comprehension for business logic built on futures. Here is a sample which contains a working example based on Exception handling: (for { // find the user by id, findUser(id) returns Future[Option[User]] userOpt <- userDao.findUser(userId) _ = if (!userOpt.isDefined) throw new EntityNotFoundException(classOf[User], userId) user = userOpt.get // authenticate it, authenticate(user) returns Future[AuthResult] authResult <- userDao.authenticate(user) _ = if (!authResult.ok) throw new AuthFailedException(userId) // find the good owned by the user,

I have a Java Future object which I would like to convert into a Scala Future . Looking at the j.u.c.Future API, there is nothing much that I could use other than the isDone method. Is this isDone method blocking? Currently this is what I have in my mind: val p = Promise() if (javaFuture.isDone()) p.success(javaFuture.get) Is there a better way to do this? How about just wrapping it (I'm assuming there's an implicit ExecutionContext here): val scalaFuture = Future { javaFuture.get } EDIT: A simple polling strategy could look like this (java.util.Future => F): def pollForResult[T](f: F[T]):

I'd like to await a scala future that may have failed. If I use Await.result the exception will be thrown. Instead, if I have f: Future[String] I would like a method Await.resultOpt(f): Option[String] or Await.resultEither(f): Either[String] . I could get this by using scala.util.control.Exception.catching or I could f map (Right(_)) recover { case t: Throwable => Left(t) } , but there must be a more straightforward way. You could use Await.ready which simply blocks until the Future has either succeeded or failed, then returns a reference back to that Future. From there, you would probably

I have three sequential Futures and use in the for comprehension like this val comF = for { f1 <- future1 f2 <- future2 f3 <- future3 } yield { // something } comF onSuccess { } comF onFailure { // ---------------- Here is the problem -------------------------------- // // How do I know which future failed(throw exception), when the callback comes here ? // Thanks for the help! Different futures using different exceptions can solve it. } Now I have a future list like List[Future[T]], and first I transfer it to Future[List[T]] using this method ( Why does this list-of-futures to future-of-list

I was just searching about this new implementation, and i use python 2.7, i must install this , so if i use it, i'll forget the word GIL on CPython? No, concurrent.futures has almost nothing whatsoever to do with the GIL. Using processes instead of threads is medicine for the GIL. (Of course, like all medicine, it has side effects. But it works.) The futures module just gives you a simpler way to schedule and wait on tasks than using threading or multiprocessing directly. And it has the added advantage that you can swap between a thread pool and a process pool (and maybe even a greenlet loop,