DS dsathyakumar

The following summarises the learnings of migrating from the async promises module to ES6 promises, with a simple sample.

Async is a library containing a bunch of async utility functions like

####The example had a combo of both:



	const UploaderMachine = Machine(
	{
	strict: true,
	id: "uploader-machine",
	context: {
	progress: false,
	progressDataModel: {
	progressMsg: "",

	// inOrder Traversal
	// Left - Data - Right

	// Note that the Data is processed only after LEFT is processed.
	// Same way, Right is processed only after Left and Data are processed.
	// So, the key here is, the moment a LEFT occurs, push it into the stack for later
	// processing.
	// So, when a Node is popped off the stack, its not guaranteed to have a RIGHT.
	// So, when we hit a LEAF node, we pop the immediate previous ancestor, but,
	// This is not guaranteed to have a RIGHT. Just process it.


	// A pre-order traversal means Data - LEFT - RIGHT
	// So, the possible combinations are
	// 1. D-L
	// No Right => Process Node and proceed with Left SubTree
	// No need to push into a stack for later processing (as there is no RIGHT)
	// 2. D-R
	// No Left => Process Node and proceed with Right SubTree.
	// No need to push into a stack for later processing (as RIGHT exists)
	// and RIGHT is being processed currently (due to absence of a LEFT)

	// Post Order traversal => Left - Right - Data
	// L-R-D
	// Possible combinations
	// 1. L-D
	// Only Left exists. Right is absent. Since the Node has to be processed after the
	// LEFT is processed, its pushed into the stack for later processing.
	// Continue process the LEFT subtree.
	// 2. R-D
	// Only Right exists. Left is absent. Since the Node has to be processed after the
	// RIGHT is processed, its pushed into the stack for later processing.

	// The Binary tree will be built with the Tree Node representation (Linked representation)
	function TreeNode(val) {
	this.val = val;
	this.left = this.right = null;
	}

	// Convert a given array of data values into a binary tree representation
	// This assumes a 0 index array
	// So for an index i, the Left Child would be at 2(i) + 1
	// The right Child will be at 2(i) + 2