CoffeeScript async/await: a concise async pattern that preserves compatibility

Problem

In JavaScript, asynchronous code is traditionally written with nested callbacks, which quickly becomes hard to read and maintain. CoffeeScript 2.x adds the ``await`` syntax, but it does not rely on native ES2017 async functions. Instead it compiles async functions into generator functions that return Promises, allowing ``await`` while keeping the code usable on older runtimes.

Minimal Design

The smallest suitable design is an async function that:

• declares a generator by returning a Promise via the ``co`` helper,
• uses ``yield`` to pause execution until a yielded Promise resolves,
• remains compatible with CommonJS modules, so existing codebases can adopt it incrementally.

This design requires only the presence of ES6 generators in the runtime; no native ``async`` keyword is needed.

Operational Checks

1. Create a CoffeeScript file with an async function, for example:

   async fetchData() ->
     await fetch(url)
     return response

2. Compile with ``coffee -c``; the output JavaScript will contain a generator wrapper around the function body.
3. Run the compiled script with Node.js 14+ (or a browser that supports ES6 generators). Verify that the function returns a Promise and that the ``await`` resolves correctly.
4. Test the same compiled code in an environment lacking generator support (e.g., IE11) or with a generator polyfill to confirm it fails without polyfills, validating the runtime dependency.
5. Inspect the generated JavaScript to ensure the ``co`` helper is invoked, showing the generator‑based Promise handling.
6. Wrap the async call in a ``try/catch`` block in the source and observe that rejections are turned into caught exceptions in the compiled output.

Failure Modes

1. Missing ``try/catch`` around an ``await`` can cause unhandled promise rejections, which may crash the process if not caught at a higher level.
2. Older browsers that do not support ES6 generators will throw a syntax error unless a polyfill is loaded, breaking the async flow.
3. Because the ``co`` helper is not tree‑shakable, including unused async functions in a client bundle adds size without functional benefit.
4. Performance‑critical paths may see a modest slowdown compared to hand‑written generator loops, as the helper adds indirection.

When to Revisit the Design

Consider redesigning the async handling when any of the following occurs:

• The target environment adopts native ``async``/``await`` (ES2017+), making the generator‑based approach redundant.
• You drop support for runtimes that lack generator support, allowing a simpler transpilation path.
• Bundle size becomes a concern and you can safely remove the ``co`` helper via modern bundlers.
• Performance profiling shows the async wrapper introduces measurable latency in hot loops.

In such cases, migrating to native async functions or a lighter transpilation strategy may be preferable.