How to reject in async/await syntax?

Your best bet is to throw an Error wrapping the value, which results in a rejected promise with an Error wrapping the value:

} catch (error) {    throw new Error(400);}

You can also just throw the value, but then there's no stack trace information:

} catch (error) {    throw 400;}

Alternately, return a rejected promise with an Error wrapping the value, but it's not idiomatic:

} catch (error) {    return Promise.reject(new Error(400));}

(Or just return Promise.reject(400);, but again, then there's no context information.)

In your case, as you're using TypeScript and foo's return value is Promise<A>, you'd use this:

return Promise.reject<A>(400 /*or Error*/ );

In an async/await situation, that last is probably a bit of a semantic mis-match, but it does work.

If you throw an Error, that plays well with anything consuming your foo's result with await syntax:

try {    await foo();} catch (error) {    // Here, `error` would be an `Error` (with stack trace, etc.).    // Whereas if you used `throw 400`, it would just be `400`.}

It should probably also be mentioned that you can simply chain a catch() function after the call of your async operation because under the hood still a promise is returned.

await foo().catch(error => console.log(error));

This way you can avoid the try/catch syntax if you do not like it.

You can create a wrapper function that takes in a promise and returns an array with data if no error and the error if there was an error.

function safePromise(promise) {  return promise.then(data => [ data ]).catch(error => [ null, error ]);}

Use it like this in ES7 and in an async function:

async function checkItem() {  const [ item, error ] = await safePromise(getItem(id));  if (error) { return null; } // handle error and return  return item; // no error so safe to use item}