After working exclusively with generators for about a month now, I believe I have gained enough experience to share some insights. Despite the lack of established best practices and clear explanations, generators are a relatively new feature in JavaScript, with limited support in platforms like node.js and Firefox (although Firefox has some deviations from the standard).

Tools like traceur and regenerator can be used to develop with generators and convert them into semi-equivalent ES5 code. If you enjoy working with generators, there's no reason not to start using them unless you need to target older browsers.

Generators

Originally not designed for handling asynchronous control flows, generators have proven to excel in this area. They function as iterator functions that can pause and resume execution through the use of the yield keyword.

The yield keyword instructs the generator to return a specific value for the current iteration and wait until next() is called to continue execution.

Generator functions are unique in that they don't execute immediately upon being called; instead, they return an iterator object with methods that allow them to be used in for-of loops and array comprehensions.

send(): Sends a value into the generator, treating it as the last yielded value before continuing to the next iteration.

next(): Moves the generator to the next iteration.

throw(): Throws an exception into the generator as if it originated from the last yield statement.

close(): Forces the generator to halt execution, triggering any final error handling logic as needed.

The ability of generators to pause and resume makes them powerful tools for managing flow control.

Co

Co was developed around the concept of utilizing generators to simplify flow control mechanisms. While it may not support all generator capabilities, it streamlines their usage with less boilerplate code. For most flow control scenarios, Co provides sufficient functionality. However, sending values into a generator during flow control could lead to intriguing possibilities...

There are other generator libraries available, such as suspend and gen-run. From my experience, Co offers the most flexibility, although suspend may be easier to grasp for those new to generators.

In terms of node.js and best practices, Co currently stands out due to the extensive support tools created for it, with suspend following closely behind.

Co works seamlessly with promises and thunks, utilizing them in yield statements to determine when to proceed with generator execution without manual intervention. It also supports generators, generator functions, objects, and arrays for enhanced flow control.

By yielding arrays or objects, Co can perform parallel operations on multiple items simultaneously. Delegating calls to nested generators allows for creating complex flow control mechanisms with minimal code overhead.

Promises

Promises, while essential for maintaining code structure, can be challenging to fully comprehend. These objects, returned by functions, track the function’s state and execute defined callbacks when certain states are reached.

Promise libraries offer valuable features like done(), not included in the ES6 specification. Their cross-compatibility between browsers and servers ensures their longevity.

Thunks

Thunks are functions that accept a callback parameter and return another function encapsulating the original method. This setup enables calling code to specify the callback to be executed upon completion.

While thunks are straightforward to utilize, they may not always be suitable for every scenario. Creating a thunk for tasks like spawning processes can be cumbersome.

Thunks vs. Promises

Although these concepts can complement each other, it’s advisable to stick to one approach for better consistency. Thunks generally exhibit faster performance due to their simpler nature lacking built-in error handling mechanisms.

However, as error handling is crucial for most applications, promises might deliver superior performance in real-world scenarios where robust error management is required.

When to Use

Generators - Ideal for applications running on modern environments like Firefox or node > 0.11.3, offering exceptional control flow mechanisms and lazy evaluation.

Promises vs. Thunks - The choice between these two depends on personal comfort and the specific needs of the project. While promises address asynchronous challenges directly, thunks ensure functions accommodate necessary callbacks for external code.

Combining promises/thunks with generators enhances control flow clarity. While not mandatory, it simplifies development and reduces the chances of encountering unhandled edge cases.

Koa

Koa, based on generators, presents a refined alternative to express, boasting advantages like improved error handling and cascading middleware. While previous solutions existed, Koa offers more elegant and efficient approaches.

Special Note: Generators hold untapped potential beyond their current applications. There are likely innovative uses waiting to be discovered by exploring their capabilities further. Future advancements in ES.next will introduce additional functionalities for harnessing the power of generators.