es6_demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ES6: Next Gen Javascript"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jargon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ECMAScript is a specification for a scripting language.\n",
    "\n",
    "Javascript is a language that implements the ECMAScript specification.\n",
    "\n",
    "Major browsers support at least ES5, which was released in 2009.\n",
    "\n",
    "ES6, or ECMAScript 2015, introduces new features **on top of** ES5.\n",
    "\n",
    "There are 7th, 8th, and 9th editions with varying amounts of adoption.\n",
    "\n",
    "ES.Next refers to the upcoming version of ECMAScript."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compatibility\n",
    "\n",
    "https://kangax.github.io/compat-table/es6/\n",
    "\n",
    "- Most up-to-date browsers have support for most of ES6. Most only lack proper tail-call optimization.\n",
    "  - Firefox 52 ESR (94%)\n",
    "  - Firefox 60 ESR (98%)\n",
    "  - Firefox 61 (98%)\n",
    "  - Chrome 67 / Opera 54 (98%)\n",
    "  - Chrome 68 / Opera 55 (98%)\n",
    "  - Safari 11 (99%)\n",
    "  - Edge 16 (96%)\n",
    "  - Edge 17 (96%)\n",
    "- Older browsers don't\n",
    "  - IE 11 (11%)\n",
    "  - Konqueror 4.14 (5%)\n",
    "- Solutions\n",
    "  - Transpilers\n",
    "    - Babel\n",
    "  - Polyfills"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Scoping](#Scoping)\n",
    "- [Classes](#Classes)\n",
    "- [Arrow Functions](#Arrow-Functions)\n",
    "- [Parameter Handling](#Parameter-Handling)\n",
    "- [Template Literals](#Template-Literals)\n",
    "- [Extended Object Properties](#Extended-Object-Properties)\n",
    "- [Generators](#Generators)\n",
    "- [Built-in Methods](#Built-in-Methods)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scoping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Introduces block scoping, rather than function scoping in ES5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since there's no block scoping, `x` now refers to the `x` in the for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    var x = 12;\n",
    "\n",
    "    for (var x = 0; x < 4; x++) {\n",
    "        console.log(x);\n",
    "    }\n",
    "    console.log(x);\n",
    "})()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With block scoping, the `x` outside of the for loop refers to previously defined `x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let x = 12;\n",
    "\n",
    "    for (let x = 0; x < 4; x++) {\n",
    "        console.log(x);\n",
    "    }\n",
    "    console.log(x);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without block scoping, these lazy functions use the last value of `i` when executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n",
      "5\n",
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    var prints_to_execute = [];\n",
    "\n",
    "    for (var i = 0; i < 5; i++) {\n",
    "        prints_to_execute.push(function () {console.log(i)})\n",
    "    }\n",
    "\n",
    "    prints_to_execute.forEach(function (f) {f()})\n",
    "})()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With block scoping, the lazy functions use the value of `i` when they were pushed into the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let prints_to_execute = [];\n",
    "\n",
    "    for (let i = 0; i < 5; i++) {\n",
    "        prints_to_execute.push(() => console.log(i))\n",
    "    }\n",
    "\n",
    "    prints_to_execute.forEach(f => f())\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More intuitive classes similar to Python, rather than prototype declaration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31.41592653589793\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    var Circle = function (x, y, radius) {\n",
    "        this.x = x\n",
    "        this.y = y\n",
    "        this.radius = radius\n",
    "    }\n",
    "    Circle.prototype.circumference = function () {\n",
    "        return 2 * Math.PI * this.radius;\n",
    "    }\n",
    "    \n",
    "    var c = new Circle(0, 0, 5);\n",
    "    console.log(c.circumference());\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31.41592653589793\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    class Circle {\n",
    "        constructor(x, y, radius) {\n",
    "            this.x = x\n",
    "            this.y = y\n",
    "            this.radius = radius\n",
    "        }\n",
    "        circumference() {\n",
    "            return 2 * Math.PI * this.radius;\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    let c = new Circle(0, 0, 5);\n",
    "    console.log(c.circumference());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simpler and more intuitive class inheritance, using super()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    var Rectangle = function (height, width) {\n",
    "        this.height = height;\n",
    "        this.width = width;\n",
    "    }\n",
    "    Rectangle.prototype.area = function () {\n",
    "        return this.height * this.width;\n",
    "    }\n",
    "    \n",
    "    var Square = function (side) {\n",
    "        Rectangle.call(this, side, side);\n",
    "    }\n",
    "    Square.prototype = Object.create(Rectangle.prototype);\n",
    "    Square.prototype.constructor = Square\n",
    "    \n",
    "    var s = new Square(4);\n",
    "    console.log(s.area());\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    class Rectangle {\n",
    "        constructor(height, width) {\n",
    "            this.height = height;\n",
    "            this.width = width;\n",
    "        }\n",
    "        area() {\n",
    "            return this.height * this.width;\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    class Square extends Rectangle {\n",
    "        constructor(side) {\n",
    "            super(side, side);\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    let s = new Square(4);\n",
    "    console.log(s.area());\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square - Rectangle - height: 4, width: 4\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    var Rectangle = function (height, width) {\n",
    "        this.height = height;\n",
    "        this.width = width;\n",
    "    }\n",
    "    Rectangle.prototype.toString = function () {\n",
    "        return \"Rectangle - height: \" + this.height + \", width: \" + this.width;\n",
    "    }\n",
    "    \n",
    "    var Square = function (side) {\n",
    "        Rectangle.call(this, side, side);\n",
    "    }\n",
    "    Square.prototype = Object.create(Rectangle.prototype);\n",
    "    Square.prototype.constructor = Square;\n",
    "    Square.prototype.toString = function () {\n",
    "        return \"Square - \" + Rectangle.prototype.toString.call(this);\n",
    "    }\n",
    "    \n",
    "    var s = new Square(4);\n",
    "    console.log(s.toString());\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square - Rectangle - height: 4, width: 4\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    class Rectangle {\n",
    "        constructor(height, width) {\n",
    "            this.height = height;\n",
    "            this.width = width;\n",
    "        }\n",
    "        toString() {\n",
    "            return `Rectangle - height: ${this.height}, width: ${this.width}`;\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    class Square extends Rectangle {\n",
    "        constructor(side) {\n",
    "            super(side, side);\n",
    "        }\n",
    "        toString() {\n",
    "            return `Square - ${super.toString()}`\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    let s = new Square(4);\n",
    "    console.log(s.toString());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrow Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrow functions make closures (anonymous functions) more concise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2, 3, 4 ]\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    var nums = [1, 2, 3];\n",
    "\n",
    "    var nums_plus_1 = nums.map(function (n) {\n",
    "        return n + 1\n",
    "    });\n",
    "\n",
    "    console.log(nums_plus_1);\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2, 3, 4 ]\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let nums = [1, 2, 3];\n",
    "\n",
    "    let nums_plus_1 = nums.map(n => n + 1);\n",
    "\n",
    "    console.log(nums_plus_1);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1, 3 ]\n"
     ]
    }
   ],
   "source": [
    "//ES5\n",
    "(function () {\n",
    "    var nums = [1, 2, 3];\n",
    "    var odds = [];\n",
    "    \n",
    "    nums.forEach(function (n) {\n",
    "        if (n % 2 != 0) {\n",
    "            odds.push(n);\n",
    "        }\n",
    "    });\n",
    "    \n",
    "    console.log(odds);\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1, 3 ]\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let nums = [1, 2, 3];\n",
    "    let odds = [];\n",
    "    \n",
    "    nums.forEach(n => {\n",
    "       if (n % 2 != 0) {\n",
    "           odds.push(n);\n",
    "       } \n",
    "    });\n",
    "    \n",
    "    console.log(odds);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrow functions have either concise bodies or block bodies. The `return` keyword can be omitted if using the concise body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let concise = n => n + 1;\n",
    "    let block = n => { return n + 1 };\n",
    "    \n",
    "    console.log(concise(1));\n",
    "    console.log(block(1));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrow functions can have multiple, or no arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let multiple = (m, n) => m + n;\n",
    "    let none = () => 1;\n",
    "\n",
    "    console.log(multiple(1, 2));\n",
    "    console.log(none());\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### No separate `this`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example below, the `this` on lines 7 and 8 refers to the Demo object.\n",
    "\n",
    "However, the `this` on line 10 does not. It is bound to the object in the `get_odds` method on line 8, but not in the forEach method on lines 9 - 11."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Cannot read property 'push' of undefined",
     "output_type": "error",
     "traceback": [
      "evalmachine.<anonymous>:10",
      "                   this.odds.push(n);",
      "                             ^",
      "",
      "TypeError: Cannot read property 'push' of undefined",
      "    at evalmachine.<anonymous>:10:30",
      "    at Array.forEach (<anonymous>)",
      "    at Demo.get_odds (evalmachine.<anonymous>:8:23)",
      "    at evalmachine.<anonymous>:18:22",
      "    at evalmachine.<anonymous>:19:3",
      "    at Script.runInThisContext (vm.js:91:20)",
      "    at Object.runInThisContext (vm.js:298:38)",
      "    at run ([eval]:1002:15)",
      "    at onRunRequest ([eval]:829:18)",
      "    at onMessage ([eval]:789:13)"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    function Demo() {\n",
    "        this.nums = [1, 2, 3];\n",
    "        this.odds = [];\n",
    "        \n",
    "        this.get_odds = function () {\n",
    "            this.nums.forEach(function (n) {\n",
    "               if (n % 2 != 0) {\n",
    "                   this.odds.push(n);\n",
    "               } \n",
    "            });\n",
    "            return this.odds;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    var demo = new Demo()\n",
    "    console.log(demo.get_odds());\n",
    "})()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get around this by saving the `this` to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1, 3 ]\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function() {\n",
    "    function Demo() {\n",
    "        this.nums = [1, 2, 3];\n",
    "        this.odds = [];\n",
    "        \n",
    "        this.get_odds = function () {\n",
    "            var self = this;\n",
    "            this.nums.forEach(function (n) {\n",
    "               if (n % 2 != 0) {\n",
    "                   self.odds.push(n);\n",
    "               } \n",
    "            });\n",
    "            return this.odds;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    var demo = new Demo()\n",
    "    console.log(demo.get_odds());\n",
    "})()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ES6 allows us to use arrow functions, which have lexical scoping, to replace workarounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1, 3 ]\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    class Demo {\n",
    "        constructor() {\n",
    "            this.nums = [1, 2, 3];\n",
    "            this.odds = [];\n",
    "        }\n",
    "        \n",
    "        get_odds() {\n",
    "            this.nums.forEach(n => {\n",
    "                if (n % 2 != 0) {\n",
    "                    this.odds.push(n)\n",
    "                }\n",
    "            });\n",
    "            return this.odds\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    let demo = new Demo();\n",
    "    console.log(demo.get_odds());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrow function cannot be used as a constructor -- if you want to use old style `prototype` objects, use normal functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Foo is not a constructor",
     "output_type": "error",
     "traceback": [
      "evalmachine.<anonymous>:7",
      "    let f = new Foo(1);",
      "            ^",
      "",
      "TypeError: Foo is not a constructor",
      "    at evalmachine.<anonymous>:7:13",
      "    at Script.runInThisContext (vm.js:91:20)",
      "    at Object.runInThisContext (vm.js:298:38)",
      "    at run ([eval]:1002:15)",
      "    at onRunRequest ([eval]:829:18)",
      "    at onMessage ([eval]:789:13)",
      "    at process.emit (events.js:182:13)",
      "    at emit (internal/child_process.js:812:12)",
      "    at process._tickCallback (internal/process/next_tick.js:63:19)"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let Foo = x => {\n",
    "        this.x = x;\n",
    "    }\n",
    "\n",
    "    let f = new Foo(1);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameter Handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default Parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Better support for default parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function() {\n",
    "    function sum(x, y, z) {\n",
    "        if (y === undefined) {\n",
    "            y = 2;\n",
    "        }\n",
    "        if (z === undefined) {\n",
    "            z = 3;\n",
    "        }\n",
    "        return x + y + z;\n",
    "    }\n",
    "    \n",
    "    console.log(sum(1));\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    function sum(x, y = 2, z = 3) {\n",
    "        return x + y + z;\n",
    "    }\n",
    "    \n",
    "    console.log(sum(1));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rest operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Represents an indefinite number of arguments as an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "[ 10, 11, 12, 13 ]\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    function rest(x, y, ...others) {\n",
    "        console.log(x);\n",
    "        console.log(y);\n",
    "        console.log(others);\n",
    "    }\n",
    "    \n",
    "    rest(1, 2, 10, 11, 12, 13);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Spread operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like the `*` operator in Python, the `...` operator can be used in a function call to unpack iterables into arguments or elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1\n",
      "y = 2\n",
      "z = 3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    function sum(x, y, z) {\n",
    "        console.log(`x = ${x}`);\n",
    "        console.log(`y = ${y}`);\n",
    "        console.log(`z = ${z}`);\n",
    "        return x + y + z;\n",
    "    }\n",
    "    \n",
    "    let nums = [1, 2, 3];\n",
    "    console.log(sum(...nums));\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 'f', 'o', 'o' ]\n",
      "[ 'f', 'o', 'o', 'b', 'a', 'r' ]\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let foo = \"foo\";\n",
    "    let foo_ray = [...foo];\n",
    "    console.log(foo_ray);\n",
    "    let bar = \"bar\";\n",
    "    let foobar = [...foo, ...bar];\n",
    "    console.log(foobar);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Template Literals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Introducing template literals, which can have interpolated expressions and multi-line strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Foo\n",
      "Bar\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function() {\n",
    "    var person = {\n",
    "        first_name: \"Foo\",\n",
    "        last_name: \"Bar\"\n",
    "    }\n",
    "    \n",
    "    var message = \"Hello, \" + person.first_name + \"\\n\" + person.last_name;\n",
    "    \n",
    "    console.log(message);\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Foo\n",
      "Bar\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let person = {\n",
    "        first_name: \"Foo\",\n",
    "        last_name: \"Bar\"\n",
    "    }\n",
    "    \n",
    "    let message = `Hello, ${person.first_name}\n",
    "${person.last_name}`;\n",
    "    \n",
    "    console.log(message);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extended Object Properties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Property Shorthand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shorthand for pattern where variables are defined outside of an object, then an object's keys are assigned those values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ a: 0, b: 0 }\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    var a = 0;\n",
    "    var b = 0;\n",
    "    \n",
    "    var foo = {\n",
    "        a: a,\n",
    "        b: b\n",
    "    }\n",
    "    \n",
    "    console.log(foo);\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ a: 0, b: 0 }\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let a = 0;\n",
    "    let b = 0;\n",
    "    \n",
    "    let foo = {\n",
    "        a,\n",
    "        b\n",
    "    }\n",
    "    \n",
    "    console.log(foo);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computed Property Names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Allows for dynamic property names in the object assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ a: 'a', b1: 'b1' }\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    function just_one() {\n",
    "        return 1;\n",
    "    }\n",
    "    \n",
    "    var foo = {\n",
    "        a: \"a\",\n",
    "    }\n",
    "    \n",
    "    foo[\"b\" + just_one()] = \"b1\"\n",
    "\n",
    "    console.log(foo);\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ a: 'a', b1: 'b1' }\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    function just_one() {\n",
    "        return 1;\n",
    "    }\n",
    "    \n",
    "    let foo = {\n",
    "        a: \"a\",\n",
    "        [\"b\" + just_one()]: \"b1\"\n",
    "    }\n",
    "    \n",
    "    console.log(foo);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method Properties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Object properties now can use method notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "// ES5\n",
    "(function () {\n",
    "    obj = {\n",
    "        sum: function (a, b) {\n",
    "            return a + b;\n",
    "        },\n",
    "        diff: function (a, b) {\n",
    "            return a - b;\n",
    "        }\n",
    "    }\n",
    "    console.log(obj.sum(1, 2));\n",
    "    console.log(obj.diff(1, 2));\n",
    "})()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    obj = {\n",
    "        sum(a, b) {\n",
    "            return a + b;\n",
    "        },\n",
    "        diff(a, b) {\n",
    "            return a - b;\n",
    "        }\n",
    "    }\n",
    "    console.log(obj.sum(1, 2));\n",
    "    console.log(obj.diff(1, 2));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Destructuring Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Matching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let list = [1, 2, 3];\n",
    "    let [a, b, c] = list;\n",
    "    console.log(a);\n",
    "    console.log(b);\n",
    "    console.log(c);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let list = [1, 2, 3];\n",
    "    let [d, , e] = list;\n",
    "    console.log(d);\n",
    "    console.log(e);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be used to swap values between 2 variables with no `temp` variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let a = 1;\n",
    "    let b = 2;\n",
    "    console.log(a);\n",
    "    console.log(b);\n",
    "    [a, b] = [b, a];\n",
    "    console.log(a);\n",
    "    console.log(b);    \n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object Matching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "{ val: 1, left: null, right: null }\n",
      "{ val: 3, left: null, right: null }\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    function getDemoBSTNode() {\n",
    "        return {\n",
    "            val: 2,\n",
    "            left: {\n",
    "                val: 1,\n",
    "                left: null,\n",
    "                right: null,\n",
    "            },\n",
    "            right: {\n",
    "                val: 3,\n",
    "                left: null,\n",
    "                right: null,\n",
    "            },\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    let {val, left, right} = getDemoBSTNode();\n",
    "    console.log(val);\n",
    "    console.log(left);\n",
    "    console.log(right);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can match objects deeply as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    function getDemoBSTNode() {\n",
    "        return {\n",
    "            val: 2,\n",
    "            left: {\n",
    "                val: 1,\n",
    "                left: null,\n",
    "                right: null,\n",
    "            },\n",
    "            right: {\n",
    "                val: 3,\n",
    "                left: {\n",
    "                    val: 4,\n",
    "                    left: null,\n",
    "                    right: null,\n",
    "                },\n",
    "                right: null,\n",
    "            },\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    let {val: a, left: {val: b}, right: {left: {val: c}}} = getDemoBSTNode();\n",
    "    console.log(a);\n",
    "    console.log(b);\n",
    "    console.log(c);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Default values can now be specified when destructuring, if the value is `undefined`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let foo = { a: 1};\n",
    "    let bar = [ 2 ];\n",
    "    let { a, b = 3 } = foo;\n",
    "    let [ c, d = 4 ] = bar;\n",
    "    \n",
    "    console.log(a);\n",
    "    console.log(b);\n",
    "    console.log(c);\n",
    "    console.log(d);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generators allow for control flow to be paused and resumed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ value: 0, done: false }\n",
      "{ value: 10, done: false }\n",
      "{ value: 20, done: false }\n",
      "{ value: 30, done: false }\n",
      "{ value: 40, done: false }\n",
      "{ value: undefined, done: true }\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    function *range(start, end, step) {\n",
    "        while (start < end) {\n",
    "            yield start;\n",
    "            start += step;\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    let r = range(0, 50, 10);\n",
    "    \n",
    "    console.log(r.next());\n",
    "    console.log(r.next());\n",
    "    console.log(r.next());\n",
    "    console.log(r.next());\n",
    "    console.log(r.next());\n",
    "    console.log(r.next());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `done` is not true until the function has been called an additional time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `of` keyword allows one to run a generator function to completion and sets the variable to the value of the generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    function *range(start, end, step) {\n",
    "        while (start < end) {\n",
    "            yield start;\n",
    "            start += step;\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    for (let i of range(0, 50, 10)) {\n",
    "        console.log(i);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`yield` will pause the generator and returns the value of the expression following the `yield` to the caller.\n",
    "When `next()` is called, the generator resumes execution, providing the value that was passed into `next`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ value: 'Expecting 3 more numbers...', done: false }\n",
      "Expecting 3 more numbers...\n",
      "100\n",
      "{ value: 'Expecting 2 more numbers...', done: false }\n",
      "Expecting 2 more numbers...\n",
      "101\n",
      "{ value: 'Expecting 1 more numbers...', done: false }\n",
      "Expecting 1 more numbers...\n",
      "102\n",
      "undefined\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    // prompt is a stand-in for window.prompt() since Jupyter doesn't support it.\n",
    "    // Imagine a user entering the number 0 when prompt is called, then 1, 2, etc.\n",
    "    function *prompt() {\n",
    "        for (let x = 100; x < 103; x ++) {\n",
    "            yield x;\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    function *take_x_numbers(x) {\n",
    "        for (let i = x; i > 0; i--) {\n",
    "            console.log(yield `Expecting ${i} more numbers...`);\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    let t = take_x_numbers(3);\n",
    "\n",
    "    let p = prompt();\n",
    "    let result = t.next(); \n",
    "    \n",
    "    while(!result.done) {\n",
    "        console.log(result);\n",
    "        console.log(result.value); // prints \"Expecting x more numbers\"\n",
    "        result = t.next(p.next().value); // passes the result of prompt into take_x_numbers\n",
    "    }\n",
    "    console.log(result.value);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array.prototype.find/.findIndex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`find` returns the value of the first element in the array that satisfies the passed-in function.\n",
    "\n",
    "`findIndex` returns the index of the first element in the array whose value satisfies the passed-in function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let nums = [1, 2, 3, 4];\n",
    "    console.log(nums.find(x => x > 2));\n",
    "    console.log(nums.findIndex(x => x > 2));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String.prototype.repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foofoofoo\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let foofoofoo = \"foo\".repeat(3);\n",
    "    console.log(foofoofoo);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String.prototype.search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "true\n",
      "true\n",
      "false\n",
      "false\n",
      "false\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    let foobarbaz = \"foobarbaz\";\n",
    "    console.log(foobarbaz.startsWith(\"foo\"));\n",
    "    console.log(foobarbaz.endsWith(\"baz\"));\n",
    "    console.log(foobarbaz.includes(\"bar\"));\n",
    "    // starting indices can be specified\n",
    "    console.log(foobarbaz.startsWith(\"foo\", 1));\n",
    "    console.log(foobarbaz.endsWith(\"baz\", 7));\n",
    "    console.log(foobarbaz.includes(\"bar\", 4));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number.isNaN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "false\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    console.log(Number.isNaN(NaN));\n",
    "    console.log(Number.isNaN(1));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number.isFinite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n",
      "false\n",
      "false\n",
      "true\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    console.log(Number.isFinite(Infinity));\n",
    "    console.log(Number.isFinite(-Infinity));\n",
    "    console.log(Number.isFinite(NaN));\n",
    "    console.log(Number.isFinite(1));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number.isSafeInteger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checks whether number can be accurately represented by JavaScript"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "false\n",
      "1e+24\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    console.log(Number.isSafeInteger(1));\n",
    "    console.log(Number.isSafeInteger(1000000000000000000000001));\n",
    "    console.log(1000000000000000000000001);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Epsilon value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can be used for comparing floating point numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n",
      "0.30000000000000004\n",
      "true\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    console.log(0.1 + 0.2 === 0.3);\n",
    "    console.log(0.1 + 0.2);\n",
    "    console.log(Math.abs((0.1 + 0.2) - 0.3) < Number.EPSILON);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Math.sign"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n",
      "-0\n",
      "-1\n",
      "NaN\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    console.log(Math.sign(10));\n",
    "    console.log(Math.sign(0));\n",
    "    console.log(Math.sign(-0));\n",
    "    console.log(Math.sign(-10));\n",
    "    console.log(Math.sign(NaN));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Math.trunc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "0\n",
      "-0\n"
     ]
    }
   ],
   "source": [
    "// ES6\n",
    "{\n",
    "    console.log(Math.trunc(10.7));\n",
    "    console.log(Math.trunc(0.1));\n",
    "    console.log(Math.trunc(-0.1));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "- Major additions\n",
    "  - Major improvements to classes and objects\n",
    "  - Generator functions\n",
    "  - `let` and `const` scoping\n",
    "  - `=>` functions\n",
    "- Smaller additions\n",
    "  - Template literals\n",
    "  - Destructuring\n",
    "  - Rest + spread operators\n",
    "  - New built-ins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sources/Research\n",
    "- http://es6-features.org/\n",
    "- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference\n",
    "- http://www.deadcoderising.com/2017-04-11-es6-var-let-and-const-the-battle-between-function-scope-and-block-scope/\n",
    "- https://medium.com/@hidace/javascript-es6-generators-part-i-understanding-generators-93dea22bf1b\n",
    "- https://coderuse.com/2016/09/JavaScript-Objects-Functions-Classes-In-ES5/\n",
    "- https://davidwalsh.name/es6-generators\n",
    "- https://kangax.github.io/compat-table/es6/\n",
    "- https://philipwalton.com/articles/deploying-es2015-code-in-production-today/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Additional Reading\n",
    "\n",
    "- Metaprogramming in ES6\n",
    "  - https://www.keithcirkel.co.uk/metaprogramming-in-es6-symbols/\n",
    "  - https://www.keithcirkel.co.uk/metaprogramming-in-es6-part-2-reflect/\n",
    "  - https://www.keithcirkel.co.uk/metaprogramming-in-es6-part-3-proxies/\n",
    "- Tail Call Optimization\n",
    "  - http://2ality.com/2015/06/tail-call-optimization.html"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Javascript (Node.js)",
   "language": "javascript",
   "name": "javascript"
  },
  "language_info": {
   "file_extension": ".js",
   "mimetype": "application/javascript",
   "name": "javascript",
   "version": "10.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}