Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Js Deferred/Promise/Future compared to functional languages like Scala

Tags:

I'm mostly using programming languages like Scala and JavaScript. I'm trying to understand the similarities and differences in how async reactive programming is used in both languages. Can you help me?

I'm not taking any particular Js Promise framework because it seems many implement the similar specifications (like Promise/A). I've only used Q so far.


It seems that in Javascript we call a Deferred the object we resolve to complete a Promise. In Scala, it seems the Promise is the object you resolve to get a Future monad.

Can someone tell me if this is right? Is there any good reason for a different usage of the term Promise between Js and Scala?


Also, in Scala we usually chain Future monads with further computations using operators like map and flatMap (also called bindin Haskell). What is the equivalent of these in Js?

I may be wrong but it appears to me that in Js the then on a Promise kind of handle both map and flatMap operators right? If so, is it possible to obtain a promise of promise of result in Js? Like we can get a Future[Future[Result]] in Scala (which can be flattened to a Future[Result] anyway).


Is Js Promise a monad? It kind of seems so even if the method names do not really match those we find on monad literature.

like image 390
Sebastien Lorber Avatar asked Mar 28 '14 23:03

Sebastien Lorber


People also ask

What is deferred promise in Javascript?

version added: 1.5deferred. The deferred. promise() method allows an asynchronous function to prevent other code from interfering with the progress or status of its internal request.

What is the difference between future and promise?

A future is a placeholder object for a result that does not yet exist. A promise is a writable, single-assignment container, which completes a future. Promises can complete the future with a result to indicate success, or with an exception to indicate failure.

Are futures asynchronous?

A future is an object that represents the result of an asynchronous computation, which may not yet be available.

Who invented promises in Javascript?

Early implementations of promises and futures (a similar / related idea) began to appear in languages such as MultiLisp and Concurrent Prolog as early as the 1980's. The use of the word “promise” was coined by Barbara Liskov and Liuba Shrira in 1988[1].


2 Answers

Yes, and no.

While extremely similar. With JavaScript Promises that comply to the Promises/A+ spec .then is not really a monadic bind and does .map and .flatMap both. Inside a .then handler when you return a promise it will recursively unwrap it.

Promise.delay(1000).then(function() {     return Promise.delay(1000).then(function () {         return Promise.delay(2000);     }).then(function () {         return Promise.delay(5000)     }); }).then(function () {     alert("This is only shown after 8 seconds and not one"); }); 

(fiddle)

You are correct that the standard JS promise libraries and the A+ spec does not feature monadic promises. They have been discussed, and implementations like fantasy-promises exist. They follow a differnet spec and have little adoption. Also see this. There has been ongoing discussion about it in the language design discussion forum - esdiscuss and a monadic .chain method that does not flatmap and allows for monadic promises is considered but unlikely to make it.

This is for pragmatic reasons. The current way promises are implemented is immensely useful. Rare are the cases you actually want a Future[Future and normally you want continuations to just work in the language. Promises 'borrow' from monads and are 'monadic' in a sense themselves. .then is very close to bind and in my head I use them interchangeably :)

It is impossible to have a Promise[Promise[Value]] like a Future[Future[Value]] in Scala with most promise libraries. You'd have to wrap it in an object and have Promise[Container[Promise[Value]]].

Promise.delay(1000).then(function () {     return Promise.delay(1000).then(function () {         return {             wrap: Promise.delay(2000).then(function () {                 return Promise.delay(5000);             })         };     }); }).then(function () {     alert("This logs after 1 second");     // I've also not seen a really solid use case      // except TypeScript type inference which is meh }); 

(fiddle)

There are also a number of other smaller differences between the two, but generally you are correct in your assertions.

like image 184
Benjamin Gruenbaum Avatar answered Oct 11 '22 12:10

Benjamin Gruenbaum


It seems that in Javascript we call a Deferred the object we resolve to >complete a Promise. In Scala, it seems the Promise is the object you >resolve to get a Future monad.

Can someone tell me if this is right? Is there any good reason for a >different usage of the term Promise between Js and Scala?

In Scala, Promise and Future have separated functionality, Future is a asynchronous computation container, which return you some value in the future, and Promise is the writing part for async-computation, which you can do something as follow

val promise = Promise[String] val future1 = promise.future val future2 = future1.map { case s => println(s); s }  future2.onSuccess { case s => println(s + " 2nd time") }  promise.success("promise completed") 

Once you execute the last statement, the output will be

promise completed promise completed 2nd time 

In Scala,you read value from Future using onComplete, or you chain it using map, and you write to a Future using it's Promise counterpart

In JS Promise A+ specs, they are bundled together, Promise.then is used for both chaining and retrieving value for side-effect (eg. console.log), to write you will use resolve like code snippet below

var promise = new Promise(function(resolve, reject){     Thread.sleep(10000);     resolve("promise completed"); } 
like image 35
Qingwei Avatar answered Oct 11 '22 10:10

Qingwei