future

I have a Seq of a tuple that looks like this: Seq[(Future[Iterable[Type1]], Future[Iterator[Type2]])] I want to transform this into the following: Future[Seq([Iterable[Type1], [Iterable[Type2])] Is this even possible? This should do the trick val a: Seq[(Future[Iterable[Type1]], Future[Iterable[Type2]])] = ... val b: Future[Seq[(Iterable[Type1], Iterable[Type2])]] = Future.sequence(a.map{ case (l, r) => l.flatMap(vl => r.map(vr => (vl, vr))) }) A bit simpler than Till Rohrmann's answer. Not tested, but should work. val seq: Seq[(Future[Iterable[Type1]], Future[Iterable[Type2]])] = ... val seq2

I have the following: val future = myActor ? Message And in my actor my receive message has something like this: sender ! Response If I do the following and ignore the response, is there any negative impact? myActor ! Message Maybe I'm just missing where it says this in the documentation. Is it like a method that returns a value and the caller doesn't assign the return value to anything? If I make that call from another actor is there going to be some weird threading issue or memory leaks that result from it? My unit tests don't seem to be affected but it's kind of a contrived. I'm hoping I'm

A std::future has a std::future::valid method, which indicates whether the future object refers to some shared state . None of the constructors construct a future object that refers to shared state (except the move constructor, which can move the shared state from one future object to another). All the methods of the class ( get , wait , wait_for and wait_until require the future object to have shared state as a precondition (they have undefined behaviour if valid() == false ). How then can a std::future acquire some shared state and become useful? You do not normally use a std::future in

I am writing some code where I might need to create an unbounded number of future objects (java.util.concurrent.Future). But I am worried about running out of memory at some point. Couple of questions here: Does the jvm know that once the future has completed, it is not being refernced anywhere and therefore is eligible for GC (even if the thread within which it was created is still alive and running)? Ideally, I wouldn't want to keep track of these futures themselves. But if I do keep the reference of these futures and periodically call cancel on them, will that make them available for GC?