javascript.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# General"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JSON vs object literal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "JSON is a data format:\n",
    "- it doesn't allow comments\n",
    "- it doesn't allow expressions or any type of flow control\n",
    "- it only support double quotes for strings\n",
    "- keys are strings and MUST be wrapped in double quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ { name: 'Mickey', surname: 'Mouse', age: 90 },\n",
       "  { name: 'Donald', surname: 'Duck', age: 84 } ]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\n",
    "  {\n",
    "    \"name\": \"Mickey\",\n",
    "    \"surname\": \"Mouse\",\n",
    "    \"age\": 90\n",
    "  },\n",
    "  {\n",
    "    \"name\": \"Donald\",\n",
    "    \"surname\": \"Duck\",\n",
    "    \"age\": 84\n",
    "  }\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Object literal is a part of the JS language:\n",
    "\n",
    "- it allows expressions and libraries\n",
    "- it allows comments\n",
    "- it supports control flow\n",
    "- it supports single quotes for strings\n",
    "- it doesn't require quotes in the keys unless they include special chars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ { name: 'Mickey', surname: 'Mouse', age: 90 },\n",
       "  { name: 'Donald', surname: 'Duck', age: 84 } ]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const mickeyAge = 90; // variables are valid here\n",
    "\n",
    "module.exports = [ // list of Disney characters\n",
    "  {\n",
    "    name: 'Mickey',\n",
    "    surname: 'Mouse',\n",
    "    age: mickeyAge\n",
    "  },\n",
    "  {\n",
    "    name: 'Donald',\n",
    "    surname: 'Duck',\n",
    "    age: mickeyAge - 6 // expressions are valid here\n",
    "  }\n",
    "];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strict Mode\n",
    "\n",
    "Strict mode is automatically enforced in ES6+, so there is no need to specify it if you are writing ES6 code.\n",
    "\n",
    "Node.js adopted **implicit strict mode** in version **6.4.0** so if you write backend code for any version greater than that, you should omit the **'use strict';** literal expression.\n",
    "\n",
    "Also, **Babel** automatically adds 'use strict'; when transpiling to ES5, so if you are writing frontend code and use Babel you can omit it as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Semicolons still matter\n",
    "\n",
    "There is a recent trend of omitting semicolons from JS code. This implies you are relying on the JS parser's ability to figure out when a statement actually ends. Is a new line a new statement or just the continuation of the precedent line? Sometimes it's hard to tell for the parser, so I still recommend using semicolons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ undefined, undefined ]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let a, b\n",
    "[a, b] = [1, 2]\n",
    "\n",
    "[a, b] = [b, a]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 2, 1 ]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let c, d;\n",
    "[c, d] = [1, 2];\n",
    "\n",
    "[c, d] = [d, c];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ES2015+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## const/let vs var\n",
    "\n",
    "- `const` and `let` are block scoped, so their behaviour is more predictable\n",
    "- `var` is only kept for backwards compatibility\n",
    "\n",
    "It is considered best practice to never alter the contents of a variable, so you should only need `let` in very rare circumstances."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### const doesn't mean immutability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ a: 3 }"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const obj = {};\n",
    "\n",
    "obj.a = 3;\n",
    "\n",
    "obj;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 'something' ]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const arr = [];\n",
    "\n",
    "arr.push('something');\n",
    "\n",
    "arr;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What you **can't** do, is assign a new reference to a variable declared with const:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const arr = ['something'];\n",
    "arr = [];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The common way of altering the content of an object or array is by using functions that return new objects/arrays with the altered values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "obj1 { name: 'Albert', surname: 'Einstein' }\n",
      "obj2 { name: 'Albert', surname: 'Of Sweden' }\n"
     ]
    }
   ],
   "source": [
    "const obj1 = { name: 'Albert', surname: 'Einstein' };\n",
    "const obj2 = Object.assign({}, obj1, { surname: 'Of Sweden' }); // or { ...obj1, { surname: 'Of Sweden' } }\n",
    "\n",
    "console.log('obj1', obj1); // old version is still intact\n",
    "console.log('obj2', obj2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr1 [ 1, 2, 3 ]\n",
      "arr2 [ 1, 2, 3, 4, 5, 6 ]\n"
     ]
    }
   ],
   "source": [
    "const arr1 = [1, 2, 3];\n",
    "const arr2 = arr1.concat([4, 5, 6]);\n",
    "\n",
    "console.log('arr1', arr1);\n",
    "console.log('arr2', arr2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### const prevents weird errors due to hoisting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "undefined\n"
     ]
    }
   ],
   "source": [
    "function failSilently() {\n",
    "  console.log(x); // undefined\n",
    "  var x = 'test';\n",
    "}\n",
    "\n",
    "failSilently();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "ReferenceError",
     "evalue": "x is not defined",
     "output_type": "error",
     "traceback": [
      "evalmachine.<anonymous>:2",
      "  console.log(x); // ReferenceError",
      "              ^",
      "",
      "ReferenceError: x is not defined",
      "    at failLoudly (evalmachine.<anonymous>:2:15)",
      "    at evalmachine.<anonymous>:6:1",
      "    at Script.runInThisContext (vm.js:96:20)",
      "    at Object.runInThisContext (vm.js:303: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": [
    "function failLoudly() {\n",
    "  console.log(x); // ReferenceError\n",
    "  const x = 'test';\n",
    "}\n",
    "\n",
    "failLoudly();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialisation and const\n",
    "\n",
    "- Use the || or ?: operators to initialize const variables that need to be calculated based on some condition\n",
    "- Create a function if the condition is too complex (too many branches)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// please DON'T do this\n",
    "\n",
    "const serialNumber = 10;\n",
    "\n",
    "let handbookChapter;\n",
    "\n",
    "if (serialNumber > 100) {\n",
    "    if (serialNumber % 2 === 0) {\n",
    "        handbookChapter = 5;\n",
    "    } else {\n",
    "        handbookChapter = 7;\n",
    "    }\n",
    "} else {\n",
    "    handbookChapter = 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code is not recommended as it leads to uninitialized variables and adds complexity in the form of nested IF statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// much better\n",
    "\n",
    "const serialNumber = 0;\n",
    "\n",
    "const handbookChapter_example1 = serialNumber || 3; // provides a default value of 3 for x\n",
    "\n",
    "const handbookChapter_example2 = (serialNumber < 10) ? 1 : 2; // sets y depending on the result of an expression\n",
    "\n",
    "function getChapter(serial) { // return a value depending on complex rules\n",
    "    if (serial > 100) {\n",
    "        return serial % 2 === 0 ? 5 : 7;\n",
    "    }\n",
    "    \n",
    "    return 0;\n",
    "}\n",
    "\n",
    "const handbookChapter_example3 = getChapter(serialNumber);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the result of a function is decided, there is no point in continuing execution with the risk of changing that value to a different and possibly wrong one. To avoid this you have to return immediately. The alternative requires you to wrap the \"rest\" of the code in an Else branch, and nesting them if necessary, making the code less readable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Single Entry, Single Exit\" as suggested by Dijkstra is pointless nowadays as it's a warning against coding styles not supported by modern languages anymore. There is no point in forcing functions to have a single RETURN statement, and enforcing this rule hinders adoption of the Guard Clause pattern, stops from concentrating error checks at the top of functions and leads to introduction of extra state variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "also:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// please DON'T do this\n",
    "\n",
    "function factoryMethod() {\n",
    "    const x = {};\n",
    "    x.a = 23;\n",
    "    x.b = 42;\n",
    "    \n",
    "    return x;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// do this instead\n",
    "\n",
    "function factoryMethod() {\n",
    "    return {\n",
    "        a: 23,\n",
    "        b: 42\n",
    "    };\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shorthand property names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const a = 1;\n",
    "const b = 2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const x = { a: a, b: b };\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const y = { a, b };\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computed property names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ '1': 4, '2': 5, d: 6 }"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const d = 1;\n",
    "\n",
    "const n = {\n",
    "  [d]: 4,\n",
    "  [d + 1]: 5,\n",
    "  d: 6\n",
    "};\n",
    "\n",
    "n;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Destructuring assignment\n",
    "\n",
    "Allows you to \"extract\" properties from an object and make them local variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "const k = { u: 7, v: 8, w: 9 };"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "u 7\n",
      "w 9\n",
      "v undefined\n"
     ]
    }
   ],
   "source": [
    "const { u, w } = k;\n",
    "\n",
    "console.log('u', u);\n",
    "console.log('w', w);\n",
    "\n",
    "console.log('v', typeof v);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bonus: destructuring u to a different variable name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h 7\n"
     ]
    }
   ],
   "source": [
    "const { u: h } = k;\n",
    "\n",
    "console.log('h', h);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It also works with function parameters. Instead of accepting a parameter of type object and then accessing its properties, we can now explicitly decide which properties we want the object to have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function f({ u, v }) {\n",
    "  console.log('u', u);\n",
    "  console.log('v', v);\n",
    "  console.log('w', typeof w);\n",
    "}\n",
    "\n",
    "f(k);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "it also works for arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const t = [7, 8, 9];\n",
    "const [i, j] = t;\n",
    "\n",
    "console.log('i', i);\n",
    "console.log('j', j);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function g([m, n, o]) {\n",
    "  console.log('m', m);\n",
    "  console.log('n', n);\n",
    "  console.log('o', o);\n",
    "}\n",
    "\n",
    "g(t);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fun to know, this can be used to swap variable values in place, without the need for a third variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 2, 1 ]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let a = 1, b = 2;\n",
    "\n",
    "[a, b] = [b, a];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrow functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implicit return, single operation\n",
    "\n",
    "In this case the function body is a single expression, which is evaluated and its result is then returned by the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const fx = (a) => a + 1;\n",
    "\n",
    "fx(3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implicit return, multiple operations\n",
    "\n",
    "This is slightly hacky, but you can use the `or` `||` and the `and` `&&` operators to perform multiple operations in a single expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const fy = (a) => console.log('log message') || a + 1;\n",
    "\n",
    "fy(3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example, in particular, works because `console.log()` returns `undefined` so the interpreter needs to evaluate the following operation `a + 1` to compute the or between the two expressions.\n",
    "\n",
    "Keep in mind that:\n",
    "- In a chain of `||`-ed expressions, the interpreter stops when it finds the first expression that evaluates to `true`; in this case it will return `true` and the following expressions will NOT be evaluated/executed; only when all the expressions evaluate to `false` will the interpreter return `false`; in this last case, all the expressions will have been executed.\n",
    "- In a chain of `&&`-ed expressions, the interpreter stops when it finds the first `false` and returns `false`; the rest of the expressions will not be evaluated; if all the expressions return `true`, it will return `true` and execute all of them.\n",
    "\n",
    "To be able to effectively use this hack, you need to:\n",
    "- know what the functions you invoke are returning\n",
    "- come up with a viable boolean expression that suits your need"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explicit return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const fz = (a) => {\n",
    "    console.log('performing calculations...');\n",
    "    \n",
    "    const b = a + 1;\n",
    "    return b;\n",
    "};\n",
    "\n",
    "fz(3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implicit return of object literal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Object literals begin with a \"{\" character exactly like code blocks, so we need a way to tell them apart. We do this by wrapping them in parenthesis ()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const fw = (a) => ({\n",
    "    u: a,\n",
    "    v: a + 1,\n",
    "    w: a + 2\n",
    "});\n",
    "\n",
    "fw(3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Template literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const character = {\n",
    "    name: 'Mickey',\n",
    "    surname: 'Mouse',\n",
    "    age: 90\n",
    "};\n",
    "\n",
    "`Hi, my name is ${character.name} ${character.surname}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can execute arbitrary code inside the ${} element in a template literal, even nested template literals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Patterns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Factories\n",
    "\n",
    "Factory methods are a commonly used technique to standardise the creation process of a family of objects. When the creation logic is complex, or there are simply rules to be followed (as is almost always the case), you may want to have a function that hides the rules under the hood and only exposes a set of parameters to configure the creation process. This is called a \"factory\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "function characterFactory(name, surname, age) {\n",
    "    return { \n",
    "        name, \n",
    "        surname, \n",
    "        age, \n",
    "        slug: `${surname.toLowerCase()}-${surname.toLowerCase()}-${age}`\n",
    "    };\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "const char1 = characterFactory('Mickey', 'Mouse', 90);\n",
    "const char2 = characterFactory('Donald', 'Duck', 86);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Closures\n",
    "\n",
    "When a function is invoked, a scope is created for it and all the variables defined in it are attached to the scope. In normal circumstances, when the function returns, its scope is forgotten and its variables can be deallocated by the garbage collector.\n",
    "\n",
    "But if a function (let's call it Parent) returns an object or another function (let's call them Child) that reference any of the variables in the scope Parent, then the scope of Parent cannot be removed but it's not accessible from anywhere except the Child.\n",
    "\n",
    "In this case Child is called `a closure`. \n",
    "\n",
    "Closures provide a way to implement:\n",
    "- pseudo-private methods/variables (anything defined in the Parent becomes inaccessible from the outside, so it's only accessible if proxied by the Child)\n",
    "- factories (every time the Parent is invoked a new scope and a new instance of Child are created and returned\n",
    "\n",
    "This also means you don't need to use **.prototype** and **this** anymore.\n",
    "\n",
    "Therefore, the need to use **new** and **.bind** is also greatly reduced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const calculatorFactory = () => {\n",
    "    const factor = 3;\n",
    "\n",
    "    const add = (c) => factor + c;\n",
    "    const multiply = (c) => factor * c;\n",
    "\n",
    "    return {\n",
    "        add,\n",
    "        multiply\n",
    "    };\n",
    "};\n",
    "\n",
    "const calculator = calculatorFactory();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calculator.add(2); // 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calculator.multiply(4); // 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calculator.factor; // undefined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the functions defined inside the factory can access all the variables in the scope of the factory, and you can decide which function will be accessible to the end-user.\n",
    "\n",
    "That's it, now you only need to use **new** when you use a an external/old-fashioned library that requires it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is even more useful if we make the factor a parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const parametricCalculatorFactory = (factor) => {\n",
    "    const add = (c) => factor + c;\n",
    "    const multiply = (c) => factor * c;\n",
    "\n",
    "    return {\n",
    "        add,\n",
    "        multiply\n",
    "    };\n",
    "};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use this factory to create many calculators that use a different `factor`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const calculator3 = parametricCalculatorFactory(3);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calculator3.add(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const calculator5 = parametricCalculatorFactory(5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calculator5.add(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a great way to pass configuration down to an object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The problem with _this_\n",
    "\n",
    "Using closures solves many problems by removing the need to use the **this** keyword. **Why is that? **\n",
    "\n",
    "The reason is that **this** refers to the *execution context* of a function, not the *originating context*. The execution context is usually not fixed, and depends on how the function is invoked. It can be passed in when calling a function, and defaults to the object containing the function.\n",
    "\n",
    "This means that by using **this** in a function you expose yourself to a lot of problems an malpractices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const originalContext = {\n",
    "    prop: 42,\n",
    "    func: function() {\n",
    "        return this.prop;\n",
    "    }\n",
    "};\n",
    "\n",
    "console.log(originalContext.func()); // 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const anotherContext = {\n",
    "    prop: 23,\n",
    "    func: originalContext.func\n",
    "};\n",
    "\n",
    "console.log(anotherContext.func()); // 23!!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const noContextFunc = originalContext.func;\n",
    "\n",
    "console.log(noContextFunc()); // boom!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last example produces **undefined** because the execution context is the **global execution context**, which doensn't contain a variable named prop.\n",
    "\n",
    "If you need to use a function like that and you want to be sure of the context, you must use **.bind()**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const fixedContextFunc = originalContext.func.bind(originalContext);\n",
    "\n",
    "console.log(fixedContextFunc()); // 42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The invocation of .bind() returns an Exotic Function Object, which is a wrapper around the original function and maintains the scope provided, so subsequent assignments to other scopes will keep the scope of the bound function unchanged. \n",
    "\n",
    "https://docs.microsoft.com/en-us/openspecs/ie_standards/ms-es6/b3c7f001-1111-1111-a005-d4a700cc1a13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is especially necessary if you want to reassign functions taken from the browser's API, such as functions coming from the **window** and **document** objects:\n",
    "\n",
    "    const addListener = document.addEventListener.bind(document);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inversion of control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**When should I use it?** \n",
    "Every time your code has a side-effect.\n",
    "\n",
    "**Why should I use it?** \n",
    "A side-effect is something that affects another part of the application, so by definition it \"couples\" two otherwise distinct parts of your project.\n",
    "\n",
    "This is bad!!! It makes your code difficult to test, reuse, maintain and refactor. You'll have to rely on external libraries like `rewire` and you'll be locked-in with your current architecture.\n",
    "\n",
    "**How do I use it?**\n",
    "Every time you need to produce a side-effect, you should do it through an object that represents the \"other\" part of the system (I'll call it the __target__). Instead of creating an instance of the object (e.g. using `new ClassName()`) in your function, you should expose the variable representing the target as a parameter of your function. Now is the external code, the code that invokes your function, that must create the target and pass it down to you.\n",
    "\n",
    "This way your code is ready to receive different versions of the target objects and you can use mock objects as targets when you want to test your code.\n",
    "\n",
    "(of course, if your function has many side-effects on different parts of the system you may need to expose/inject many different targets -- this is NOT a problem though)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine you have the following function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// calculator factory with a side effect\n",
    "const calculatorFactorySE = () => {\n",
    "  const factor = 3;\n",
    "\n",
    "  const add = (c) => console.log(`adding ${c}`) || factor + c;\n",
    "  const multiply = (c) => console.log(`multiplying ${c}`) || factor * c;\n",
    "\n",
    "  return {\n",
    "    add,\n",
    "    multiply\n",
    "  };\n",
    "};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The add and multiply methods both have side-effects in the form of a console.log() statement that prints out some information.\n",
    "\n",
    "What happens if you then want to test that the `add` method actually prints out the message? Any possible approach is difficult to implement or misleading when you try to read the test code.\n",
    "\n",
    "Everything becomes much simpler when you resort to injection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const calculatorFactory2 = (log) => {\n",
    "  const factor = 3;\n",
    "\n",
    "  const add = (c) => log(`adding ${c}`) || factor + c;\n",
    "  const multiply = (c) => log(`multiplying ${c}`) || factor * c;\n",
    "\n",
    "  return {\n",
    "    add,\n",
    "    multiply\n",
    "  };\n",
    "};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can inject different loggers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const calcToScreen = calculatorFactory2(console.log);\n",
    "\n",
    "calcToScreen.add(5); // adding 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const loggerFactory = () => {\n",
    "    const messages = [];\n",
    "    const getMessages = () => messages;\n",
    "    const logger = (msg) => messages.push(msg);\n",
    "    return { getMessages, logger };\n",
    "};\n",
    "\n",
    "const { getMessages, logger } = loggerFactory();\n",
    "\n",
    "const calcToArray = calculatorFactory2(logger);\n",
    "\n",
    "calcToArray.add(5);\n",
    "\n",
    "console.log(getMessages());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mock objects\n",
    "\n",
    "Inversion of control makes it easier to work with mock objects. All you have to do is create an object implementing the same interface as the object you are mocking, and inject it into the function or factory you are trying to test.\n",
    "\n",
    "The simplest way to do this is by making the mock object push log strings into an array and then using the array to check that all the expected steps have been performed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const fs = require('fs');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const getRamdaVersion = () => {\n",
    "    const packageInfo = JSON.parse(fs.readFileSync('./package.json', 'utf-8'));\n",
    "    return packageInfo.dependencies.ramda;\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "getRamdaVersion();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How do you mock the package.json file in function getHighlandVersion? We expose `fs` as a dependency to be injected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const getRamdaVersion = (fs) => {\n",
    "    const packageInfo = JSON.parse(fs.readFileSync('./package.json', 'utf-8'));\n",
    "    return packageInfo.dependencies.ramda;\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const mockFs = {\n",
    "    readFileSync: () => JSON.stringify({ dependencies: { ramda: 'xyz' } })\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mockFs.readFileSync('test');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "getRamdaVersion(fs);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "getRamdaVersion(mockFs);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functional programming\n",
    "\n",
    "Functional programming aims at reducing the complexity of a system by transforming a program into a pipeline through which data flows. The pipeline is made of many stations where the data is transformed and progressively refined until it reaches the desired shape.\n",
    "\n",
    "In its purest form, functional programming is a pain when it comes to state management. When used with moderation, however, it drastically reduces boilerplate code and can make programs easier to write, read and maintain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions are first-class citizens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In JS a function is a full-blown object, with it's own methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function citizen() {\n",
    "    return 'Kane';\n",
    "}\n",
    "\n",
    "console.log(citizen.toString());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Higher-order functions are functions that return other functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function firstOrderFunction() {\n",
    "    return 'Hi';\n",
    "}\n",
    "\n",
    "function higherOrderFunction() {\n",
    "    return firstOrderFunction();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Currying\n",
    "\n",
    "Currying a function splits it into multiple nested functions, so that you can invoke them one at a time. The simplest way to explain it is graphically, say you have this function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "function f(a, b) {\n",
    "    return a * b;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you normally invoke it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest \"curried\" version of `f(a, b)` is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "function fc(a) {\n",
    "    return function(b) {\n",
    "        return a * b;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so you can invoke it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fc(3)(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this obviously works because returning `fc_a` creates a closure so that `fc_a` can still access the value of the parameter `a` of the enclosing function `fc`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Invoking fc with only one parameter returns the internal function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Function]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fc(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means that you don't need to know both parameters `a` and `b` at the same time. When `a` is available you can pass it to the curried function and it will return another function (`fc_a` in this case, but it's usually an anonymous function) that already contains the value for `a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n",
      "9\n",
      "12\n",
      "15\n",
      "18\n",
      "21\n",
      "24\n",
      "27\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "// print all multiples of 3 from 1st to 10th\n",
    "\n",
    "for (let i = 1; i <= 10; i++) {\n",
    "    console.log(f(3, i))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n",
      "9\n",
      "12\n",
      "15\n",
      "18\n",
      "21\n",
      "24\n",
      "27\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "// print all multiples of 3 from 1st to 10th\n",
    "// using curried function\n",
    "\n",
    "const fc_3 = fc(3); \n",
    "// now fc_3 is a function that takes only one parameter and returns 3 * param\n",
    "\n",
    "for (let i = 1; i <= 10; i++) {\n",
    "    console.log(fc_3(i))\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that doing this using arrow functions makes the declaration ultra-compact:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const fc = (a) => (b) => a * b;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also note that Ramda contains an **R.curry** function that takes a normal function and returns the curried version of the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const R = require('ramda');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function f(a, b) {\n",
    "    return a * b;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const curried_f = R.curry(f);\n",
    "\n",
    "console.log(curried_f(5)); // [Function]\n",
    "console.log(curried_f(5)(4)); // 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map, Filter, Reduce\n",
    "\n",
    "Very often, the only reason to use a loop statement (such as `for` or `while`) is to go through all the elements of a collection in order to perform the same action of the all the elements of the collection. This kind of operations can be greatly simplified with the use of Map/Filter/Reduce."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map\n",
    "\n",
    "The map method applies a function to all elements in an array, and returns the results in an array with the same order as the initial one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "const numbers = [0, 4, 2, 0, 1, 5, 3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 0, 8, 4, 0, 2, 10, 6 ]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers.map(function(n) { \n",
    "    return 2 * n;\n",
    "});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// using arrow functions\n",
    "numbers.map((n) => 2 * n);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "// using currying\n",
    "const R = require('ramda');\n",
    "const f = R.curry((a, b) => a * b);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers.map((n) => f(2)(n));\n",
    "\n",
    "const f2 = f(2);\n",
    "const I = (n) => n;\n",
    "\n",
    "(n) => f2(n)\n",
    "\n",
    "f2\n",
    "\n",
    "numbers.map((n) => f2(n));\n",
    "numbers.map(f2);\n",
    "numbers.map(f(2));\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that writing `(n) => f(n)` is exactly the same as writing just `f`\n",
    "\n",
    "So in our case `(n) => f(2)(n)` is exactly the same as just `f(2)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 0, 8, 4, 0, 2, 10, 6 ]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// simplifying\n",
    "numbers.map(f(2));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "const introduce = (character) => `Hi, my name is ${character.name} ${character.surname}`;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi, my name is Stefano Butera'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "introduce({ name: 'Stefano', surname: 'Butera' })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 'Hi, my name is Mickey Mouse', 'Hi, my name is Donald Duck' ]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const chars = [\n",
    "  {\n",
    "    name: 'Mickey',\n",
    "    surname: 'Mouse',\n",
    "    age: 90\n",
    "  },\n",
    "  {\n",
    "    name: 'Donald',\n",
    "    surname: 'Duck',\n",
    "    age: 84\n",
    "  }\n",
    "];\n",
    "\n",
    "chars.map(introduce);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter\n",
    "\n",
    "The `filter` method selects only the elements of an array that satisfy a specified condition. The condition is expressed as a function that is given one element of the array and can return `true` or `false` in order to keep it or discard it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "const isOldEnough = (character) => character.age > 86;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isOldEnough({ age: 10 })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isOldEnough({ age: 100 })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ { name: 'Mickey', surname: 'Mouse', age: 90 } ]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const chars = [\n",
    "  {\n",
    "    name: 'Mickey',\n",
    "    surname: 'Mouse',\n",
    "    age: 90\n",
    "  },\n",
    "  {\n",
    "    name: 'Donald',\n",
    "    surname: 'Duck',\n",
    "    age: 84\n",
    "  }\n",
    "];\n",
    "\n",
    "chars.filter(isOldEnough);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since both map and filter return arrays, they can also be chained:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chars.filter(isOldEnough).map(introduce)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's worth notice that since the Boolean() constructor returns `true` or `false` depending on the truthiness or falseness of the parameter, it can be used to easily filter out all falsy elements from an array (i.e. null, zero or undefined values):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 4, 2, 1, 5, 3 ]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const numbers = [0, 4, 2, 0, 1, 5, 3];\n",
    "\n",
    "numbers.filter(Boolean);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce\n",
    "\n",
    "Reduce takes an array and combines all its elements together in an `accumulator`, using a given function to perform the aggregation. It then returns the accumulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "const reducer = (acc, val) => acc + val;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "const numbers = [0, 4, 2, 0, 1, 5, 3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers.reduce(reducer, 5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers\n",
    "    .filter((n) => n > 3)\n",
    "    .reduce(reducer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "41"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers\n",
    "    .filter((n) => n > 3)\n",
    "    .map((m) => m ** 2)\n",
    "    .reduce(reducer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ramda\n",
    "Ramda is a data-last auto-currying functional toolkit for JavaScript and NodeJS: it emphasizes a purer functional style. Immutability and side-effect free functions are at the heart of its design philosophy. Ramda makes it simple to build complex logic through functional composition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## R.map, R.filter, R.reduce\n",
    "\n",
    "Ramda provides stand-alone versions of the map/filter/reduce functions (and much more).\n",
    "\n",
    "These functions are also curried, so you can apply them partially. This is especially useful for use in composition (see R.pipe)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const R = require('ramda')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const numbers = [0, 4, 2, 0, 1, 5, 3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const reducer = (acc, val) => acc + val;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const squareAll = R.map((n) => n ** 2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squareAll(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const gt3 = R.map((n) => n > 3);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gt3(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const sumAll = R.reduce(reducer, 0);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sumAll(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## R.pipe\n",
    "\n",
    "R.pipe allows you to create higher-order function by composing existing functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const R = require('ramda');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const reducer = (acc, val) => acc + val;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const numbers = [0, 4, 2, 0, 1, 5, 3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const transform = R.pipe(\n",
    "    R.filter((n) => n > 3),\n",
    "    R.map((m) => m * m),\n",
    "    R.reduce(reducer, 0)\n",
    ");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform(numbers);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Promises\n",
    "\n",
    "A promise is an object representing the future result of an asynchronous operation.\n",
    "\n",
    "The basic interface of a promise has two methods:\n",
    "- `then()` is invoked when the asynchronous operation is completed; the result value of the operation is passed to the callback as a parameter; any value or promise returned by the callback is itself elevated to a promise, so the `then` methods can be chained;\n",
    "- `catch()` is invoked when the promise resolves to an error or when it raises an exception; this means that you don't need to have try/catch blocks in a `then` callback, you can just chain a `catch` to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const request = require('request-promise');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "request('https://reststop.randomhouse.com/resources/authors?lastName=Grisham')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use cases\n",
    "\n",
    "### How to start a promise chain\n",
    "\n",
    "Most libraries that provide asynchronous functionality provide a promise-based interface. This means that you can usually just invoke the asynchronous function and start chaining `then` and `catch` right away, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "request('https://reststop.randomhouse.com/resources/authors?lastName=Grisham')\n",
    "    .then((res) => {\n",
    "        console.log('list of books from Grisham', res);\n",
    "    })\n",
    "    .catch((err) => {\n",
    "        console.log('error trying to access API', err);\n",
    "    });"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you only have a callback-based function, such as any function from Node's core library, you can get a promise-based version of it by using **util.promisify()**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const { promisify } = require('util');\n",
    "const { readFile } = require('fs');\n",
    "\n",
    "const readFileP = promisify(readFile);\n",
    "\n",
    "readFileP('./package.json')\n",
    "    .then((res) => {\n",
    "        console.log(res);\n",
    "    });"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "readFileP('./package.json')\n",
    "    .then((res) => res.toString('utf-8'));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "readFileP('./package.json', 'utf-8')\n",
    "    .then((json) => JSON.parse(json)) // same as .then(JSON.parse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Last but not least, you can start a promise chain using `Promise.resolve(value)`, which returns a promise resolving to `value`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const R = require('ramda');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const numbers = [0, 4, 2, 0, 1, 5, 3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Promise.resolve(numbers)\n",
    "    .then(R.filter((number) => number > 2));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is especially useful when you then need to apply asynchronous functions along the way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const request = require('request-promise');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Promise.resolve(numbers)\n",
    "    .then(R.filter((number) => number > 2))\n",
    "    .then(R.map((number) => request(`http://numbersapi.com/${number}`)))\n",
    "    .then((promises) => Promise.all(promises))\n",
    "    .catch(console.log);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Returning a value from a `then`\n",
    "\n",
    "Just return it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "request(`http://numbersapi.com/23`)\n",
    "    .then((factoid) => `The fact of the day about number 23 is that ${factoid}`)\n",
    "    .then(console.log)\n",
    "    .catch(console.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resolving a promise from inside a `then`\n",
    "\n",
    "Just return it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "request(`https://openlibrary.org/people/george08/lists/OL97L/seeds.json`)\n",
    "    .then(JSON.parse)\n",
    "    .then((listInfo) => listInfo.entries)\n",
    "    .then(R.filter((entry) => entry.type === 'subject'))\n",
    "    .then((subjects) => subjects[0].full_url)\n",
    "    .then((subjectUrl) => {\n",
    "        const nestedPromise = request(`https://openlibrary.org${subjectUrl}.json`);\n",
    "        return nestedPromise;\n",
    "    })\n",
    "    .then(JSON.parse)\n",
    "    .then(console.log)\n",
    "    .catch(console.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Promise.all()\n",
    "\n",
    "What if I must pass on multiple values? **Just wrap them in an array**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Promise.resolve()\n",
    "    .then(() => ['Stefano', 'Butera'])\n",
    "    .then((res) => console.log(res))\n",
    "    .catch(console.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also destructure the array to improve readability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Promise.resolve()\n",
    "    .then(() => ['Stefano', 'Butera'])\n",
    "    .then(([firstName, lastName]) => {\n",
    "        console.log('first name: ', firstName);\n",
    "        console.log('last name: ', lastName);\n",
    "    })\n",
    "    .catch(console.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if I must also pass on multiple promises or mixed variables and promises?\n",
    "In this case you can't just wrap them in an array, as the promises would be passed on **unresolved**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Promise.resolve(42)\n",
    "    .then((number) => [number, request(`http://numbersapi.com/${number}`)])\n",
    "    .then(([number, factoid]) => {\n",
    "        console.log('number: ', number);\n",
    "        console.log('factoid: ', factoid);\n",
    "    })\n",
    "    .catch(console.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, you'll have to use **Promise.all()**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Promise.resolve(42)\n",
    "    .then((number) => Promise.all([number, request(`http://numbersapi.com/${number}`)]))\n",
    "    .then(([number, factoid]) => {\n",
    "        console.log('number: ', number);\n",
    "        console.log('factoid: ', factoid);\n",
    "    })\n",
    "    .catch(console.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simply put, when you pass an array to Promise.all(), all the values contained in the array will be passed on as they are, while the promises will be resolved and replaced with their result values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Highland.js\n",
    "Highland is a high-level streams library for Node.js. It’s thought to manage synchronous and asynchronous code easily by providing a common interface to Promises, Callbacks, EventEmitters via Node Native Streams. It’s lazy-evaluated and supports backpressure.\n",
    "\n",
    "Ramda and Highland work perfectly together and make a perfect couple if you want to write good stream-oriented functional code. In the next example, Ramda and Highland are used to scrape the Star Wars APIs to get all paginated results from an endpoint. The goal of the following script is to create a stream that self-feeds with new pages urls as they come through, until there are no pages left to consume. The consumed url is https://swapi.co/api/people which will return a list of Star Wars characters as JSON objects, 10 per page.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const R = require('ramda');\n",
    "const hl = require('highland');\n",
    "const request = require('request');\n",
    "\n",
    "const requestStream = hl.streamifyAll(request); // (1)\n",
    "\n",
    "// url :: String\n",
    "const url = 'https://swapi.co/api/people';\n",
    "\n",
    "// nextLens :: Lens\n",
    "const nextLens = R.lensPath(['next']); // (2)\n",
    "\n",
    "// setNil :: Any -> Either Any HighlandStream.nil\n",
    "const setNil = R.defaultTo(hl.nil); // (3)\n",
    "\n",
    "// httpStream :: HighlandStream\n",
    "const httpStream = hl(); // (4)\n",
    "\n",
    "httpStream.write(url); // (5)\n",
    "\n",
    "httpStream\n",
    "   .flatMap(requestStream.getStream) // (6)\n",
    "   .map(R.prop('body')) // (7)\n",
    "   .map(JSON.parse) // (8)\n",
    "   .map(R.over(nextLens, setNil)) // (9)\n",
    "   .tap(body => httpStream.write(body.next)) // (10)\n",
    "   .tap(console.log) // (11)\n",
    "   .done(R.identity); // (12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `streamifyAll` is an Highland utility that gets an object or a constructor function as input and returns it with all of its functions or methods streamified but preserving their execution context (no binding is needed to use them). In other words, any function expecting a callback to deal with asynchronous operations or returning a promise will be transformed so that it can be used as though it was an highland stream.<br>In this case, `streamifyAll` is wrapping the request module. This means that all of the functions available in request will expose the same interface as an highland stream. <br>`streamifyAll` appends the word Stream to every available function name: as in `(6)`, instead of passing `request.get`, `requestStream.getStream` is passed in.<br>\n",
    "2. `lensPath` is a Ramda utility that creates a lens to access/mutate the property next of an object, given a specified path. More on lenses here.<br>\n",
    "3. `defaultTo` is a Ramda utility that creates a function that returns a default value (in this case hl.nil) if the provided value is null or undefined. `hl.nil` is special value that marks the end of a stream. If hl.nil is written to a stream, that stream consumers will know the stream has been terminated. <br>`setNil` is a function that takes one input and will return either the original input or hl.nil if the original input is null or undefined.<br>\n",
    "4. Initializes an empty Highland stream<br>\n",
    "5. Writes the url string to the stream initialized in `(4)`. <br>\n",
    "6. `flatMap` executes `requestStream.getStream` on every string that is written to the stream and returns a new stream of results. All of the results are then emitted on a single output stream. In this case, the results are http response objects.<br>\n",
    "7. `R.prop` extracts the value of the body property from the objects on the stream. `map` will propagate the extracted values downstream. At this stage the value of body is a String. <br>\n",
    "8. `JSON.parse` will be applied to every String pushed downstream by the previous step and re-emit the thus parsed object on the stream.\n",
    "9. `setNil` is applied to the body object through nextLens: this step actually mutates the body objects selectively on `body.next`\n",
    "10. `tap` is used to mutate the stream and to perform side effects. Objects on the stream will be passed downstream. In this case a side effect is performed: the value of `body.next` is written back to the `httpStream`.<br>This is how the stream is self-feeding with urls as they become available in the next property. This step represents the core of the logic: `body.next` can be either a url String or `hl.nil` and, regardless of its value, it is pushed back on the stream. <br>In the first case the string will trigger the step `(6)` and a new page will be fetched. Alternatively, `hl.nil` will terminate the stream. Notice how no explicit loops or recursive logic is leaking out of this declarative implementation.\n",
    "11. Again `tap` is used to perform side effects, in this case to `console.log` out the value that are on the stream.\n",
    "12. `done` calls a function (also referred as sink) once the stream has ended, in this case `R.identityz`. Notice how this is the step in which the stream is actually consumed. This is the expected behavior, as Highland is thought to be lazy evaluated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some additional considerations:  \n",
    "- Notice how Ramda being auto-currying and data-last facilitates the usage of highland pipelines: in most cases, no explicit reference is made to the objects tap, map and flatMap are operating on. The only explicit reference to the data and its structure is made on step (10), for all other steps it was possible to just pass a function expecting the data as only argument to every step of the pipeline.\n",
    "- This approach makes testing and debugging easy, as it’s always possible to, either programmatically or manually, change the transformation in a given step, add or remove steps.\n",
    "- Currying makes it easier to keep dependency injection under control while facilitating unit testing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Javascript (Node.js)",
   "language": "javascript",
   "name": "javascript"
  },
  "language_info": {
   "file_extension": ".js",
   "mimetype": "application/javascript",
   "name": "javascript",
   "version": "8.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}