Looking at your error traceback, it looks like you are using python 3.5. Is that the case? If so, then the error happens because according to PEP-563 the import of __future__ annotations is available starting with Python 3.7. I did not find any hints that this will be backported to previous versions, but I might … Read more
You are correct, and apart from calling wait_until with a time in the past (which is equivalent) there is no better way. You could always write a little wrapper if you want a more convenient syntax: template<typename R> bool is_ready(std::future<R> const& f) { return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready; } N.B. if the function is deferred this … Read more
Let’s use this as our Minimal, Reproducible Example: async fn foo(x: u8) -> u8 { 2 * x } struct S { foo: (), } async fn example() { let s = S { foo }; } It produces the error: error[E0308]: mismatched types –> src/main.rs:10:17 | 10 | let s = S { foo … Read more
it’s called async, but it got a really “sequential behaviour”, No, if you use the std::launch::async policy then it runs asynchronously in a new thread. If you don’t specify a policy it might run in a new thread. basically in the row where you call the future associated with your async function foo, the program … Read more
The way an ExecutorService works is that when you call invokeAll it waits for all tasks to complete: Executes the given tasks, returning a list of Futures holding their status and results when all complete. Future.isDone() is true for each element of the returned list. Note that a completed task could have terminated either normally … Read more
I might be mistaken, but your function doesn’t need to be tail recursive in this case. Tail recursion helps us to not consume the stack in case we use recursive functions. In your case, however, we are not actually consuming the stack in the way a typical recursive function would. This is because the “recursive” … 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
The case of Success(listInt) => I want to return the listInt and I am not able to figure out how to do that. The best practice is that you don’t return the value. Instead you just pass the future (or a version transformed with map, flatMap, etc.) to everyone who needs this value and they … Read more
This answer is from monkjack, a comment from the accepted answer. However, one can miss this great answer so I’m reposting it here. implicit val ec = ExecutionContext.fromExecutor(Executors.newFixedThreadPool(10)) If you just need to change the thread pool count, just use the global executor and pass the following system properties. -Dscala.concurrent.context.numThreads=8 -Dscala.concurrent.context.maxThreads=8
(I’m not completely happy with the answers so far, so here is my attempt…) I think that Kevin Wright’s comment You can make a Promise and it’s up to you to keep it. When someone else makes you a promise you must wait to see if they honour it in the Future summarizes it pretty … Read more