async / await and PromiseLike

[dbaeumer]

async function delay(millis: number): PromiseLike<void> {
    return Promise.resolve(undefined);
}

The code above is not valid and is rejected by the compiler.

Could you explain why a PromiseLike is not sufficient as a return value. I looked at the generated code and I couldn't spot an obvious reason.

[mhegazy]

if you use a type annotation, it is going to be used to create the promise object wrapping the return value. there is no "value" named PromiseLike, so it is going to fail at runtime.
so either do not give it a type annotation, and it would be inferred to be the built-in "Promise", or use a Promise library.

[Arnavion]

Also, since you're returning a promise and not the value, you don't need to mark it as async anyway.

[dbaeumer]

This might get complicated if you use two libraries which use different promise implementation. Then the code needs to wrap them.

I still think that the code should allow PromiseLike.The awaiter code the compiler generate could still create an instance of a Promise since it conforms to PromiseLike. However the cast method must not do an instanceof Promise check. Instead it would need to check for a then function. All the awaiter code needs right now is a then function.

[yortus]

@dbaeumer if you want to annotate the return value as PromiseLike<T>, then just return a value assignable to type T from the async function and it works fine. E.g.:

async function f1(): PromiseLike<void> {
    /* ...some async operation... */
    return;
}

async function f2(a: number, b: number): PromiseLike<number> {
    /* ...some async operation... */
    return a + b;
}

async function f3(): PromiseLike<string> {
    /* ...some async operation... */
    return 'foo';
}

EDIT: Ahhh, I think I see the error you are talking about now:

Type PromiseLike<...> is not a valid async function return type

I tend to agree - the compiler is being too strict here. PromiseLike<any> is a valid annotation for any async function return value, because whatever promise instance is returned is sure to be assignable to it.

[dbaeumer]

@Arnavion shorten my example to much. I need the async keyword since I want to use await in the body. Something like:

declare function use(): PromiseLike<number>;

async function delayer(millis: number): Promise<void> {
    let result = await use();
    return Promise.resolve(undefined);
}

[yortus]

@dbaeumer but why do you need the line return Promise.resolve(undefined);? Why not just allow the async body to return - it will wrap the return value in a promise - you don't need to create the promise explicitly. i.e.:

async function delayer(millis: number) {
    await use();
}

That will return Promise<void>, no need for any annotations or creating explicit promises.

[yortus]

Is this what you are trying to do:

async function delayer(millis) {
    await new Promise(resolve => setTimeout(resolve, millis));    
}

That will return a Promise<void> that resolves after millis milliseconds, and the resolution value will be undefined.

[dbaeumer]

@yortus the example is not about implementing a delayer :-). Here is what I want to do: I have a library that provides APi to others. This API is speced in terms of PromiseLike. Now I want to asyncfy the library. To do so I need to change all signatures to return Promise instead of PromiseLike otherwise I can't use await inside the implementation. This is still doable. What I don't fully understand what will happen if I have code like this:

function imported(): PromiseLike<string> {
   // returns a Promise that is not the 'native' Promise implementation in node.
}

async function wrap() {
    return imported();
} 

async function use {
    var value = await wrap();
    console.log(value);
}

Will this always print a string value or could it happen to be the Promise type returned by imported(). The awaiter code does some instanceof Promise checks. If it always prints the strings I think it would be more clear if async functions return a PromiseLike

I tested it with the Promise implementation form here https://github.com/then/promise and it returned a string.

[yortus]

@dbaeumer if you do it like this it should always work regardless of promise implementation:

function imported(): PromiseLike<string> {
   // returns a Promise that is not the 'native' Promise implementation in node.
}

async function wrap() {
    return await imported(); // 'unwraps' the PromiseLike and 're-wraps' as native promise
} 

async function use {
    var value = await wrap();
    console.log(value);
}

[yortus]

@dbaeumer to add to the above, the instanceof checks in the awaiter should only relate to return values inside async functions, so that if a Promise<T> is returned it does not get wrapped into a Promise<Promise<T>>.

But the await operator should work with any A+ thenable regardless of what its specific implementation is. So return await x works with any thenable x.

[dbaeumer]

@yortus I know, but this might be error prone. And in C# I can always return the called async method without await which is very nice (and to my knowledge save some CPU cycles)

[jrieken]

@dbaeumer Isn't it possible to just await a function returning a promise (no async marker)?

function delay(t: number): PromiseLike<void> {
        return new Promise<void>(resolve => { 
            setTimeout(resolve, t);
        });
    }

    await delay(1000);

[yortus]

@dbaeumer Awaiting an A+ promiselike won't be error prone. If you're worried about the performance difference between return x and return await x, benchmark it and see. Given that async functions are downleveled to ES6 generators which V8 can't optimise, I think you'll find any performance difference very minor next to the slowdown due to the generator body not being optimised.

[dbaeumer]

@yortus what I meant with error prone is that people might forget it (especially if they come from a C# background).