The easiest way is to start from the entry node of the graph, as if you were writing the code by hand. In order to solve the join problem, you can not use a recursive solution, you need to have a topological ordering of your graph, and then build the graph according to the ordering. … Read more
An example of each, using javascript since everybody can read it. Please don’t use this code in production, use a real library, there are plenty of good ones. var a, b, c, async_obj; // assume exist // CommonJS – for reference purposes try { async_obj.asyncMethod(a, b, c, function (error1, result1) { if (error1) { console.error(error1); … Read more
You can call get() on a Future as often as you like, and it will only block if the task that produces the result has not finished yet. If the task has already finished, it will just immediately return the result of the task. If the task has failed with an exception, calling get() will … Read more
You can use the Stream method firstWhere to create a future that resolves when your Stream emits a true value. Future<bool> whenTrue(Stream<bool> source) { return source.firstWhere((bool item) => item); } An alternative implementation without the stream method could use the await for syntax on the Stream. Future<bool> whenTrue(Stream<bool> source) async { await for (bool value … Read more
executor.map(), like the builtin map(), only returns results in the order of the iterable, so unfortunately you can’t use it to determine the order of completion. concurrent.futures.as_completed() is what you’re looking for – here’s an example: import time import concurrent.futures times = [3, 1, 2] def sleeper(secs): time.sleep(secs) print(‘I slept for {} seconds’.format(secs)) return secs … Read more
Edit 2017-09-18: As of Scala 2.12, there is a transform method that takes a Try[T] => Try[S]. So you can write val future = … // Future[T] val mapped = future.transform { case Success(_) => Success(“OK”) case Failure(_) => Success(“KO”) } For 2.11.x, the below still applies: AFAIK, you can’t do this directly with a … Read more
You need to get the bool out of Future<bool>. Use can then block or await. with then block _checkConnection() { Utiliy.checkConnection().then((connectionResult) { Utility.showAlert(context, connectionResult ? “OK”: “internet needed”); }) } with await _checkConnection() async { bool connectionResult = await Utiliy.checkConnection(); Utility.showAlert(context, connectionResult ? “OK”: “internet needed”); } For more details, refer here.
In Dart 3, you should use a Record of Futures instead of a List/Iterable so that you can have heterogeneous types. Dart 3 provides wait extensions for such Records that are similar to Future.wait. (See sudormrfbin’s answer for an example.) If you must use Future.wait, you need to adapt each of your Future<T>s to a … Read more
The second option is best, it keeps everything asynchronous. but… you can do one better and abstract the solution into a reusable pattern: implicit class RichListenableFuture[T](lf: ListenableFuture[T]) { def asScala: Future[T] = { val p = Promise[T]() Futures.addCallback(lf, new FutureCallback[T] { def onFailure(t: Throwable): Unit = p failure t def onSuccess(result: T): Unit = p … Read more
val result: Future[(Class1, Class2, Class3)] = for { _ <- Future.unit val f1 = process1 val f2 = process2 val f3 = process3 v1 <- f1 v2 <- f2 v3 <- f3 } yield (v1, v2, v3)