async functions are effectively desugared as returning impl Future. Once you know that, it’s a matter of combining existing Rust techniques to accept a function / closure, resulting in a function with two generic types: use std::future::Future; async fn example<F, Fut>(f: F) where F: FnOnce(i32, i32) -> Fut, Fut: Future<Output = bool>, { f(1, 2).await; … Read more
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 want to get the Future’s value, which is an Option[Try[T]]. Due to the Await.ready call, it should be safe to assume that the value is a Some. … Read more
You can use Future.any constructor to make a race condition final result = await Future.any([ Future.value(42), Future.delayed(const Duration(seconds: 3)) ]); You can also use Future.timeout method final result = await Future.value(42).timeout(const Duration(seconds: 3));
Future.apply(None) creates asynchronous computation and executes it. It means that extra lambda object is created and extra task is scheduled (however trivial task). Future.successful(None) just produces already completed future. It is more efficient.
You can use the Future.wait method documented here: https://api.dart.dev/stable/dart-async/Future/wait.html
Akka has akka.pattern: def after[T](duration: FiniteDuration, using: Scheduler)(value: ⇒ Future[T])(implicit ec: ExecutionContext): Future[T] “Returns a scala.concurrent.Future that will be completed with the success or failure of the provided value after the specified duration.” http://doc.akka.io/api/akka/2.2.1/#akka.pattern.package
You don’t need to return anything manually, since an async function will only return when the function is actually done, but it depends on how/if you wait for invocations you do in this function. Looking at your examples you are missing the async keyword, which means you need to write the following instead: Future<void> deleteAll(List … Read more
If you have a future, let’s say, Future[HttpResponse], and you want to specify what to do with that result when it is ready, such as write the body to a file, you may do something like responseF.map(response => write(response.body). However if write is also an asynchronous method which returns a future, this map call will … Read more
(Edited to give a correct answer!) The key here is that Future and Option don’t compose inside for because there aren’t the correct flatMap signatures. As a reminder, for desugars like so: for ( x0 <- c0; w1 = d1; x1 <- c1 if p1; … ; xN <- cN) yield f c0.flatMap{ x0 => … Read more
In your ReentrantReadWriteLock class, try changing self._condition = Condition()