Changing The THIS Binding And Execution Context Of A Generator In Node.js

// Require the core node modules.
var chalk = require( "chalk" );

// ----------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------- //

// I create a Generator Object that tests the "this" binding.
function* genfunk() {

	console.log( chalk.red.bold( "[Generator]" ) );
	console.log( chalk.red( "[this]:" ), this );

}

var generator = genfunk();

// Now that the Generator Object has been created, let's see if we can change the
// context binding of the iterable method at execution time using .call().
// --
// CAUTION: THIS DOES NOT WORK (KEEP READING THE ARTICLE, BRO)
generator.next.call({
	description: "I was bound to the generator using .next.call()."
})

// Let's test to see what ".this" binding is in place.
gen.next();

// Require the core node modules.
var chalk = require( "chalk" );

// ----------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------- //

// I create a Generator Object that tests the "this" binding.
function* genfunk() {

	console.log( chalk.red.bold( "[Generator]" ) );
	console.log( chalk.red( "[this]:" ), this );

}

// When we invoke the generator function, we can use the .call() / .apply() methods to
// change the execution context of the resultant Generator Object. Once we do this, all
// calls to .next(), .throw(), and .return() will execute with the given .this binding.
var generator = genfunk.call({
	description: "I was bound to the generator using .call()."
});

// Let's test to see what ".this" binding is in place.
generator.next();

// Require the core node modules.
var chalk = require( "chalk" );

// ----------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------- //

// I am a generator functions that yields 3 times, requiring 4 calls to .next() in order
// to be fully consumed.
function* genfunk() {

	console.log( chalk.red.bold( "(1)" ), "this.description:", this.description );
	yield;

	console.log( chalk.red.bold( "(2)" ), "this.description:", this.description );
	yield;

	console.log( chalk.red.bold( "(3)" ), "this.description:", this.description );
	yield;

	console.log( chalk.red.bold( "(4)" ), "this.description:", this.description );

}

// ----------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------- //

// Once the Generator Object is created by the generator function, we can't change the
// execution context of it directly. However, we can set the execution context of the
// Generator Object at creation time. This means that we can use PROTOTYPAL INHERITANCE
// to expose a portion of the prototype chain that we can change. This "proxy context"
// will be the execution context of the Generator Object throughout the entire execution;
// however, we'll be able to CHANGE THE PROTOTYPE OF THE PROXY in order to dynamically
// change the context of the Generator.
// --
// CAUTION: Due to the way prototypal inheritance works, if you SET A VALUE INTO THE
// PROTOTYPE CHAIN, it will be stored in the closest link in the prototype chain. As
// such, you can read from the higher-up prototypes, but, you can't write to them.
var proxyContext = Object.create( null );

// Create the Generator Object using the "proxy" as the execution context (ie, the
// "proxyContext" will be used as the "this" binding internally).
var generator = genfunk.call( proxyContext );

// Now, let's inject a convenience method into the Generator Object that will allows us
// to change the prototype chain at execution time.
generator.bindTo = function( newContext ) {

	Object.setPrototypeOf( proxyContext, newContext );

};

// ----------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------- //

// These are the various prototypal contexts that we'll be using to alter the execution
// binding of the Generator as it starts to yield values.
var contextA = {
	description: "I am context A."
};
var contextB = {
	description: "I am context B."
};
var contextC = {
	description: "I am context C."
};

// Now that our Generator Object has been built using a this-context that can be swapped
// at any time, let's try consuming the values, changing the context between each of the
// .next() invocations.
generator.next();

generator.bindTo( contextA );
generator.next();

generator.bindTo( contextB );
generator.next();

generator.bindTo( contextC );
generator.next();