New async.sync like async.apply for sync functions.

[reggi]

I came up with an async.sync call that's like async.apply except for synchronous functions. Checkout the bottom example that uses path.join async.sync(path.join, "/hello", "world", "awesome").

var path = require("path");
var async = require("async");
var _ = require("underscore");

async.sync = function() {
  var args = arguments;
  args = Array.prototype.slice.call(args);
  var fn =  args.shift();
  return function(callback) {
    var exe = fn.apply(null, args);
    return callback(exe);
  }
}

async.waterfall([
  async.sync(path.join, "/hello", "world", "awesome")
], function(err, results) {
  console.log(err);
  console.log(results);
});

[aearly]

👍 for the idea. I end up writing this function all the time. Needs a try/catch to handle any possible errors, though. And the final name probably needs some bikeshedding.

[reggi]

Thanks @aearly! I think the general reaction is that the whole point is that we should be only worrying about async functions. I think this is good for flow-control keeping async functions plug-and-play. It really depends on your philosophy, and there may be a bigger divide there.

[aearly]

I've added acomb.asyncify with this functionality to my helper library. It might be worth adding to async, but I'll wait for more opinions.

[aearly]

And ideas for what to name this?

• async.asyncify(JSON.parse)
• async.ify(JSON.parse)
• async.sync(JSON.parse)
• async.fromSync(JSON.parse)
• async.toAsync(JSON.parse)
• async.wrapSync(JSON.parse)
• …

[reggi]

@aearly From my example above, I personally like like sync.

[aearly]

I'm not a fan of async.sync, because it's not really "syncing" anything -- it's shorthand for an adjective, not a verb. It's also too generic for what it's doing.

Whats your second choice? 😄

[reggi]

@aearly Makes sense.

I like async.wrapSync because that is more inline with what is being done, and it's easy to read the whole way through without your head wanting to explode.