future

I have the following code: #include <iostream> #include <future> #include <chrono> #include <thread> using namespace std; int sleep_10s() { this_thread::sleep_for(chrono::seconds(10)); cout << "Sleeping Done\n"; return 3; } int main() { auto result=async(launch::async, sleep_10s); auto status=result.wait_for(chrono::seconds(1)); if (status==future_status::ready) cout << "Success" << result.get() << "\n"; else cout << "Timeout\n"; } This is supposed to wait 1 second, print "Timeout", and exit. Instead of exiting, it waits an additional 9 seconds, prints "Sleeping Done", and then segfaults. Is

I am reading through the Scala Cookbook ( http://shop.oreilly.com/product/0636920026914.do ) There is an example related to Future use that involves for comprehension. So far my understanding about for comprehension is when use with a collection it will produce another collection with the same type. For example, if each futureX is of type Future[Int] , the following should also be of type Future[Int] : for { r1 <- future1 r2 <- future2 r3 <- future3 } yield (r1+r2+r3) Could someone explain me what exactly happening when use <- in this code? I know if it was a generator it will fetch each

I'm looking for a way to convert an arbitrary length list of Futures to a Future of List. I'm using Playframework, so ultimately, what I really want is a Future[Result] , but to make things simpler, let's just say Future[List[Int]] The normal way to do this would be to use Future.sequence(...) but there's a twist... The list I'm given usually has around 10-20 futures in it, and it's not uncommon for one of those futures to fail (they are making external web service requests). Instead of having to retry all of them in the event that one of them fails, I'd like to be able to get at the ones that

I'm trying to understand Future::select : in this example, the future with a longer time delay is returned first. When I read this article with its example, I get cognitive dissonance. The author writes: The select function runs two (or more in case of select_all ) futures and returns the first one coming to completion. This is useful for implementing timeouts. It seems I don't understand the sense of select . extern crate futures; extern crate tokio_core; use std::thread; use std::time::Duration; use futures::{Async, Future}; use tokio_core::reactor::Core; struct Timeout { time: u32, } impl