Conjuring JQuery Deferred with monadic incantations

Question

Inspired by this (excellent) discussion of using Promises in javascript, I'm trying to work out how I could use Deferred to chain together async and non-async functions, to avoid paying the callback tax when using my 'Global storage' code.

I've got a few questions related to this, but I'll ask them together here, because the context is the same.

One thing I can't work out is how I can make a deferred out of something that isn't asynchronous - that is, how do I take a value, wrap it in a promise, and return it directly? (a -> M<a>)

Also, how can I take an asynchronous function and wrap it so that it returns its result directly, but wrapped in a promise? ((a -> b) -> (a -> M<b>))

Last question, for monadic freaks - is there a standard name for this function? [a] -> (a -> M<b>) -> M<[b]>

For anyone who's landed here trying to work out how to 'chain' deferred objects, I've come up with (what seems to me like) an elegant solution: http://jsfiddle.net/Benjol/DjrRD/ — Benjol, Apr 17 '11 at 09:50

score 5 · Answer 1 · answered Aug 23 '11 at 00:53

5

Wrapping a value into a promise is as simple as using $.when:

var promise = $.when( value );

Also, as of jQuery 1.6, you have a very simple chaining method (pipe):

var chained = functionThatReturnsAPromise().pipe(function( resolveValue ) {
        return functionThatReturnsAnotherPromise( resolveValue );
    });

chained.done(function() {
    // Both asynchronous operations done in sequence
});

Hope this helps.

answered Aug 23 '11 at 00:53

Julian Aubourg

11,346
1
29
29

Very nice, thanks. As it happens, I was tailoring it for here, where they haven't upgraded to 1.6 yet (AFAIK), but the $.when is handy. – Benjol Aug 23 '11 at 04:53
For anyone that's curious, `$.when(value)` is shorthand for `$.Deferred().resolve(value).promise()` – chaz Mar 09 '14 at 19:31

score 1 · Answer 2 · edited Apr 06 '11 at 17:19

1

I think the way that you'd turn a value into a Promise is to just "pre-succeed" the Deferred:

function v2p(value) {
  var rv = $.Deferred();
  rv.resolveWith(null, [value]);
  return rv.promise();
}

Now passing a function to ".done()" will result in the function being immediately called with the value.

v2p("hello").done(function(value) { alert(value); });

would immediately alert "hello".

edited Apr 06 '11 at 17:19

Benjol

63,995
54
186
268

answered Apr 06 '11 at 16:45

Pointy

405,095
59
585
614

1

That's a great start, thanks! I edited your answer to get it to run, hope it hasn't denatured what you meant. – Benjol Apr 06 '11 at 17:19
Oh yes, right; sorry about that. I have only barely played with that Deferred stuff so far, but it seems really cool :-) – Pointy Apr 06 '11 at 17:30

Benjol · Answer 3 · 2011-04-16T16:11:11.690

Helped along by @Pointy, implementing 'lift' becomes trivial:

function unit(value) {
  var rv = $.Deferred();
  rv.resolveWith(null, [value]);
  return rv.promise();
}
function lift(fn) {
  return function(x) {
    return unit(fn(x));
  };
}
lift(alert)("hello");

function bind(fn) {
   return function(x) {
     return x.done(function(y) { return fn(y); });
   }
}

function compose(f, g) { return function(x) { g(f(x)); } };
function twice(x) { return 2 * x; }
var alert2 = compose(bind(lift(twice)), bind(lift(alert)));

alert2(unit(4)); //error at the end because alert doesn't return any values

Now I just have to work out how to implement [a] -> (a -> M<b>) -> M<[b]>, and what to call it!

EDIT, I ended up implementing (a -> M<b>) -> ([a] -> M<[b]>) instead, it looks like this:

function listBind(fn) {
    return function(a) {        
      var Mb = $.Deferred();
      var b = [], pending = a.length;
      var callback = function(i,val) {
         b[i] = val;
         if(--pending == 0) Mb.resolve(b);
      };
      for(var i = 0, n = a.length; i < n; i++) {
          (function(closure) { //ugly, but have to use closure to 'copy' i
             fn(a[closure]).done(function(val) { callback(closure, val); })
          })(i);
      }
      return Mb.promise();
    };
}

So, given a function which gets one deferred item, this function listBind returns a new function which accepts an array of values, and uses them to return another list of values inside a deferred item.

Conjuring JQuery Deferred with monadic incantations

3 Answers3

Linked