There is also: f recover { case cause => throw new Exception(“Something went wrong”, cause) } Since Scala 2.12 you can do: f transform { case s @ Success(_) => s case Failure(cause) => Failure(new Exception(“Something went wrong”, cause)) } or f transform { _.transform(Success(_), cause => Failure(new Exception(“Something went wrong”, cause)))}
One common approach to waiting for all results (failed or not) is to “lift” failures into a new representation inside the future, so that all futures complete with some result (although they may complete with a result that represents failure). One natural way to get that is lifting to a Try. Twitter’s implementation of futures … Read more
What you observe is expected behaviour – yet of course it’s very bad. Good that known solutions and best practices exist to guard against it. In this answer I’d like to spend some time to explain the issue short, long, and then in depth – enjoy the read! Short answer: “don’t block the routing infrastructure!“, … Read more
In both Python and ES6, await/async are based on generators. Is it a correct to think Futures are the same as Promises? Not Future, but Python’s Task is roughly equivalent to Javascript’s Promise. See more details below. I have seen the terms Task, Future and Coroutine used in the asyncio documentation. What are the differences … Read more
I cannot answer it all, but i try on some parts: Is there some reason that the “most asynchronous” behavior—i.e., don’t consume the collection before returning, and don’t wait for each future to complete before moving on to the next—isn’t represented here? If you have dependent calculations and a limited number of threads, you can … Read more
ExecutionException and InterruptedException are two very different things. ExecutionException wraps whatever exception the thread being executed threw, so if your thread was, for instance, doing some kind of IO that caused an IOException to get thrown, that would get wrapped in an ExecutionException and rethrown. An InterruptedException is not a sign of anything having gone … Read more
Since it’s similar to async & await in C#, maybe I can provide some insight. In C#, it’s a general rule that Task that can be awaited should be returned ‘hot’, i.e. already running. I assume it’s the same in Scala, where the Future returned from the function does not have to be explicitly started, … Read more
Well, when you have multiple generators in a single for comprehension, you are flattening the resulting type. That is, instead of getting a List[List[T]], you get a List[T]: scala> val list = List(1, 2, 3) list: List[Int] = List(1, 2, 3) scala> for (a <- list) yield for (b <- list) yield (a, b) res0: … Read more
The C++11 standard does not provide a direct way to cancel a task started with std::async. You will have to implement your own cancellation mechanism, such as passing in an atomic flag variable to the async task which is periodically checked. Your code should not crash though. On reaching the end of main, the std::future<int> … Read more
You can use Future.wait to wait for several Future to be completed. body: FutureBuilder<List<FlashCardList>>( future: Future.wait([ fetchFlashCardList(), fetchFlashCardListFromDB(), ]),