future

I have a scenario where I have to poll a remote server checking if a task has completed. Once it has, I make a different call to retrieve the result. I originally figured I should use a SingleThreadScheduledExecutor with scheduleWithFixedDelay for polling: ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); ScheduledFuture future = executor.scheduleWithFixedDelay(() -> poll(jobId), 0, 10, TimeUnit.SECONDS); public void poll(String jobId) { boolean jobDone = remoteServer.isJobDone(jobId); if (jobDone) { retrieveJobResult(jobId); } } But since I can only provide a

Does Haskell have an equivalent of Alice's ability to bind a variable to a future? val a = spawn foo; where foo is some function. I know Haskell supports channels and threads; I'm hoping for syntax as natural as Alice's to bind a value to a future and spawn a thread to calculate it without having to deal with the details. You can use par from Control.Parallel as in a `par` f a b c where a = foo This is a hint to the runtime that a could be evaluated in another thread. Funny, I was just reading a new post by Simon Marlow: Parallel programming in Haskell with explicit futures . Apparently he and

I'm working on using Futures for the first time in Scala and am working through an example of using the flatMap combinator; I've been following this discussion: http://docs.scala-lang.org/overviews/core/futures.html Specifically, this example: val usdQuote = future { connection.getCurrentValue(USD) } val chfQuote = future { connection.getCurrentValue(CHF) } val purchase = for { usd <- usdQuote chf <- chfQuote if isProfitable(usd, chf) } yield connection.buy(amount, chf) purchase onSuccess { case _ => println("Purchased " + amount + " CHF") } is translated to this: val purchase = usdQuote

Recently I've delved into a little bit of work using an API. The API uses the Unirest http library to simplify the work of receiving from the web. Naturally, since the data is called from the API server, I tried to be efficient by using asynchronous calls to the API. My idea is structured as follows: Create array of data by returning the results of futures Display data + additional information gathered from the data Therefore, I need to have all the data returned before I can start the second step. My code is as follows: Future < HttpResponse < JsonNode > > future1 = Unirest.get("https:/

The andThen meaning I learned from this answer is a function composer. Say that f andThen g andThen h will equal to h(g(f(x))) This implies the h function will receive input from g(f(x)) But for the andThen in Future , all the closure of the following andThen always receives the result from the original Future . Future{ 1 }.andThen{ case Success(x) => println(x) // print 1 Thread.sleep(2000) x * 2 }.andThen{ case Success(x) => println(x) // print 1 Thread.sleep(2000) x * 2 } compare to val func: Function1[Int, Int] = { x: Int => x }.andThen { y => println(y) // print 1 y * 2 }.andThen { z =>

I have 3 futures of type Response. The first future returns a JsValue which defines if future 2 and future 3 shall be executed or only future 3 shall be executed. Pseudocode: If Future 1 then {future2 and future 3} else future 3 Iam trying to do this in a play framwork action which means in order to use the result of the futures later I cant use onSuccess, onFailure and onComplete because all of them return Unit and not the actual JsValue from the last future. I tried to do this with map() and andThen but I am a Scala noob and I guess i wasn't able to do it because I always just missed a

How can I convert Option[Future[T]] to Future[Option[T]] in scala? I want to use it in: val customerAddresses = for { a <- addressDAO.insert(ca.address) // Future[Address] ia <- ca.invoiceAddress.map(addressDAO.insert) // Option[Future[Address]] } yield (a, ia) // Invalid value have to be two futures Here signature insert method def insert(address: Address): Future[Address] ca is a CustomerData case class CustomerData(address: Address, invoiceAddress: Option[Address]) import scala.concurrent.Future import scala.concurrent.ExecutionContext def f[A](x: Option[Future[A]])(implicit ec: