Treat functions without a callback as promises

The current behavior is very surprising:

await async.parallel({foo: async()=>Promise.all([1,2])})
// { foo: [ 1, 2 ] }
await async.parallel({foo: ()=>Promise.all([1,2])})
// waits forever because non-async function expects a ballback

Because for short functions, it’s tempting to just write foo: () => doSomething(). It’s very easy to forget the async keyword there

But currently this won’t work, it needs to be written as foo: async () => doSomething()

Could we rather check if a callback is passed or not, instead of checking if the function is an AsyncFunction?

[m0uneer]

@caub This is the reason https://github.com/caolan/async/blob/8aecf108b3922bc5211036706a0f6f75e02bd42b/lib/internal/wrapAsync.js#L3:L5

function isAsync(fn) {
    return fn[Symbol.toStringTag] === 'AsyncFunction';
}

This way, it’s easier to check if the function returns a promise without actually calling it. But still agree with you that this is against the async/await conventions. As adding an async keyword without an internal await is considered a bad practice in most of cases actually.

from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function

The body of an async function can be thought of as being split by zero or more await expressions. Top-level code, up to and including the first await expression (if there is one), is run synchronously.

… and so it’ll be useless and worst it will add some performance overhead if the code is transpiled by babel for example as it’ll add more code and steps just because of the existence of the async keyword

For example, the following:

async function foo() {
   return 1
}

…is equivalent to:

function foo() {
   return Promise.resolve(1)
}

but with this library,

async.mapLimit([1], 1, async v => v)

and

async.mapLimit([1], 1, v => Promise.resolve(v)))

are not equivalent!

[flatcoding]

Even with this issue closed, as of the linked issue above, I’d like to re-emphasize on @caub statements here. The current behaviour confused me a lot, and while I (kind of) understand the technical limitations discussed here, I believe that the documentation is simply not in line with the current behaviour. For e.g. mapLimit it says “Returns: a promise, if no callback is passed” - I started with the callback version, and then basically left out the callback and was surprised that I don’t get the Promise (because I didn’t have the ‘async’ keyword). also, the ‘callback’ statement in the iteratee function isn’t needed then, instead you need to ‘return’ a value. So, either the behaviour should be changed (preferred) or at least documentation and examples should be aligned in my point of view to avoid confusion.