Let's break down this JavaScript code and explain each part: ```js const promise = Promise.resolve() // ^<< //[Here, `promise` is created as a resolved promise. ]<< //[This promise resolves immediately with an undefined value.]<< function f() { // ^ //[`f` is a function that simply returns this pre-made promise.]<< return promise } async function a() { return f() } // ^ //[`a` is an async function that returns the result of `f()`. ]<< //[Since `f()` returns a promise, `a()` will return this promise as well. ]<< //[However, because `a` is async, it will wrap this promise in another promise.]<< async function b() { return await f() } // ^ //[ `b` is also an async function. It awaits the result of `f()`. ]<< //[The `await` means `b` will wait for promise returned in `f()` to resolve before returning.]<< //[Since `f()` returns an already resolved promise, ]<< //[`b` will return the value of that promise (which is `undefined`) wrapped in a new promise]<< function c() { return f() } // ^ //[`c` is a regular (non-async) function that returns the result of `f()`. ]<< //[It returns the same promise as `f()`.]<< ``` All comparisons will log `false` because they compare different promise objects. ```js console.log(a() === b()) // false console.log(b() === c()) // false console.log(a() === c()) // false ``` ## Read More Below is the [ECMA Spec](https://tc39.es/ecma262/#sec-runtime-semantics-evaluateasyncfunctionbody) on how `async` function body should be evaluated. > ### 15.8.4 Runtime Semantics: EvaluateAsyncFunctionBody > > The syntax-directed operation EvaluateAsyncFunctionBody takes arguments functionObject (an ECMAScript function object) and argumentsList (a List of ECMAScript language values) and returns a return completion. It is defined piecewise over the following productions: > *AsyncFunctionBody : FunctionBody* > 1. Let *promiseCapability* be ! *NewPromiseCapability(%Promise%)*. > 2. Let *completion* be *Completion(FunctionDeclarationInstantiation(functionObject, argumentsList))*. > 3. If *completion* is an abrupt completion, then > - Perform ! *Call(promiseCapability.[[Reject]], undefined, « completion.[[Value]] »)*. > 4. Else, > - Perform *AsyncFunctionStart(promiseCapability, FunctionBody)*. > 5. Return *Completion Record { [[Type]]: return, [[Value]]: promiseCapability.[[Promise]], [[Target]]: empty }*. We can see that it basically means creating a new Promise that wraps the return value of the function body.

Discuss (14)