Javascript“Promises”和函数式编程的“任务”之间有什么区别？

Question

Besides lazy execution, are Tasks and Promises pretty much the same thing? When I refer to a task, I refer to a class that is in its most basic behavior like the following:

class Task {
  constructor(then) {
    this.then = then;
  }
  map(mapper) {
    return new Task((resolve, reject) => this.then(
      x => resolve(mapper(x)),
      reject
    ))
  }
  flatMap(mapper) {
    return new Task((resolve, reject) => this.then(
      x => mapper(x).then(resolve, reject),
      reject
    ))
  }
}

What type of (class?) is a task/promise? I'm learning about functional programming approaches, but I don't think I've gotten to this type yet. Is it a type of monad?

Answer 1

Yes, the key thing is a monadic bind, or a flatMap in your case that has the signature:

Task A -> A -> Task B -> Task B

With promises - that's the then method that:

Promise A -> (A -> Promise B) -> Promise B
 this          onFulfilled        return value

In fact, both are instances of the Continuation Monad . Lots of other things (like Rx streams) are instances of the continuation monad.

Promises in JavaScript however are specced with a slightly different (and uglier, for arguably practical reasons) signature with it being possible to also return a plain value from then , and there are exception semantics involved.

There was a push for more "monadic" promises back in 2013 when they were specced, but it failed. The current promises in JavaScript aren't really "monad"s per-se.

Answer 2

A. promises are one refactoring step further than callback.just that. if you have a function

const f = x =>  x * x ;

1) Use Callback and remove return type

you can pass a callback and remove the return type. This the famous Continuation-passing style

const f1 = (x,callback)=>callback(x*x);

What if we curry the action and return it as a result ?! we could do this :

const squareCont = (x)=>callback=>callback(x*x);

if you look at this for a long time and rename callback to resolve you will see that this is actually a promise.

//i rewrited it to make it clearer
var squareCont = function(x){
   return function (resolve){return resolve (x*x);}
}

[Side Note : we could make it into a Promise if we enclose the callback into an object that exposes a then function like that :

const squarePromise = (x)=>({then:callback=>callback(x*x)});

squarePromise(2).then(r=>console.log(r))

check the fiddle here] B.Task is the Coninuation Co-Monad . Because i cannot summarize it here you can read in more detail here : Promises & Continuation Monad in JavaScript and here Async/await aka Continuation Co- Monad in JavaScript