index.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0f279d84",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:55:56.6071334-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:55:56.5737763-06:00"
   },
   "source": [
    "Up and Running with F#\n",
    "======================\n",
    "A gentle guide to a powerful language\n",
    "\n",
    "> ⚠️ This website is under construction!\n",
    "\n",
    "[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://github.com/codespaces/new?template_repository=johnW-ret/fstandsforfun)\n",
    "[![Open in VS Code](media/open-in-vscode.svg)](vscode://vscode.git/clone?url=https://github.com/johnW-ret/fstandsforfun)\n",
    "<small>[[ open in `github.dev` ]](https://github.dev/johnW-ret/fstandsforfun)</small>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a43660bd",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:55:56.6105874-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:55:56.6096253-06:00"
   },
   "source": [
    "F# is composed of **expressions**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d110897d",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:55:59.5610328-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:55:56.6106294-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>6</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// expressions separated by `;`s\n",
    "1; 2; 3\n",
    "\n",
    "// expressions separated by new lines\n",
    "4\n",
    "5\n",
    "6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37256815",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:55:59.5616622-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:55:59.5610687-06:00"
   },
   "source": [
    "If you wrap expressions with `[||]`, you get an **array**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4ca52325",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:55:59.602707-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:55:59.5616759-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>[ 1, 2, 3 ]</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// This is an array.\n",
    "[| 1; 2; 3 |]\n",
    "\n",
    "// This is also an array.\n",
    "[|\n",
    "    1\n",
    "    2\n",
    "    3\n",
    "|]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a51b838",
   "metadata": {},
   "source": [
    "Every expression in F# has a **type**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "abc"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "1               // int\n",
    "2.              // float\n",
    "2.0             // float\n",
    "\"abc\"           // string"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45bc0899",
   "metadata": {},
   "source": [
    "All elements of an array must be the of the same **type**. So `[| 1; \"a\"; true |]` is not valid."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c7fa6f9",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:55:59.6031373-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:55:59.6027499-06:00"
   },
   "source": [
    "In F#, the `,` separates tuple elements, not collection elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<details open=\"open\" class=\"dni-treeview\"><summary><span class=\"dni-code-hint\"><code>(1, 2)</code></span></summary><div><table><thead><tr></tr></thead><tbody><tr><td>Item1</td><td><div class=\"dni-plaintext\"><pre>1</pre></div></td></tr><tr><td>Item2</td><td><div class=\"dni-plaintext\"><pre>2</pre></div></td></tr></tbody></table></div></details><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// two-ple\n",
    "1, 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ada78109",
   "metadata": {},
   "source": [
    "Tuples are useful for all kinds of things in F#, and the language comes with a terse syntax for representing them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6dfe016e",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:55:59.6397836-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:55:59.6031502-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<details open=\"open\" class=\"dni-treeview\"><summary><span class=\"dni-code-hint\"><code>(6, 7)</code></span></summary><div><table><thead><tr></tr></thead><tbody><tr><td>Item1</td><td><div class=\"dni-plaintext\"><pre>6</pre></div></td></tr><tr><td>Item2</td><td><div class=\"dni-plaintext\"><pre>7</pre></div></td></tr></tbody></table></div></details><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// 4-ary tuple\n",
    "3, 4, 5, 6\n",
    "\n",
    "// Unlike collections (lists and arrays), tuples can hold parameters of different types.\n",
    "\"Erica\", 34, false\n",
    "\n",
    "// Sometimes parentheses are required\n",
    "(6, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f82a6fd",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:02.1398404-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:02.1393207-06:00"
   },
   "source": [
    "Let's use tuples and arrays together to plot some points. We can install [Plotly.NET](https://plotly.net/) from [NuGet](https://www.nuget.org/) and use it all in one go:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "439eb48c",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:02.8497319-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:02.1398542-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div></div><div></div><div><strong>Installed Packages</strong><ul><li><span>Plotly.NET, 5.0.0</span></li><li><span>Plotly.NET.Interactive, 5.0.0</span></li></ul></div></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Loading extensions from `C:\\Users\\retru\\.nuget\\packages\\plotly.net.interactive\\5.0.0\\lib\\netstandard2.1\\Plotly.NET.Interactive.dll`"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Use this syntax to install packages from **NuGet**.\n",
    "// (Only necessary in interative mode. Otherwise can be installed with the command line with `dotnet add <PackageName>`.)\n",
    "#r \"nuget: Plotly.NET\"\n",
    "#r \"nuget: Plotly.NET.Interactive\"\n",
    "\n",
    "// Use this syntax to open a module or a namespace.\n",
    "open Plotly.NET\n",
    "open Plotly.NET.LayoutObjects\n",
    "\n",
    "// set some default styling (ignore for now)\n",
    "let margin = 30.\n",
    "Defaults.DefaultHeight <- 400\n",
    "Defaults.DefaultWidth <- 0\n",
    "Defaults.DefaultTemplate <- Template.init(Layout.init(AutoSize = true, Margin = Margin.init(Top = margin, Left = margin, Right = margin, Bottom = margin)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3d8dddb5",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div id=\"abaac984-33ca-4b55-89e0-286a9e080855\"><!-- Plotly chart will be drawn inside this DIV --></div><script type=\"text/javascript\">\n",
       "var renderPlotly_abaac98433ca4b5589e0286a9e080855 = function() {\n",
       "    var fsharpPlotlyRequire = requirejs.config({context:'fsharp-plotly',paths:{plotly:'https://cdn.plot.ly/plotly-2.27.1.min'}}) || require;\n",
       "    fsharpPlotlyRequire(['plotly'], function(Plotly) {\n",
       "        var data = [{\"type\":\"scatter\",\"mode\":\"markers\",\"x\":[1,2,3],\"y\":[2,4,3],\"marker\":{},\"line\":{}}];\n",
       "        var layout = {\"width\":0,\"height\":400,\"template\":{\"layout\":{\"margin\":{\"l\":30.0,\"r\":30.0,\"t\":30.0,\"b\":30.0},\"autosize\":true},\"data\":{}}};\n",
       "        var config = {\"responsive\":true};\n",
       "        Plotly.newPlot('abaac984-33ca-4b55-89e0-286a9e080855', data, layout, config);\n",
       "    });\n",
       "};\n",
       "if ((typeof(requirejs) !==  typeof(Function)) || (typeof(requirejs.config) !== typeof(Function))) {\n",
       "    var script = document.createElement(\"script\");\n",
       "    script.setAttribute(\"charset\", \"utf-8\");\n",
       "    script.setAttribute(\"src\", \"https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.6/require.min.js\");\n",
       "    script.onload = function(){\n",
       "        renderPlotly_abaac98433ca4b5589e0286a9e080855();\n",
       "    };\n",
       "    document.getElementsByTagName(\"head\")[0].appendChild(script);\n",
       "}\n",
       "else {\n",
       "    renderPlotly_abaac98433ca4b5589e0286a9e080855();\n",
       "}\n",
       "</script></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Chart.Point([|\n",
    "    1, 2\n",
    "    2, 4\n",
    "    3, 3\n",
    "|])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0311dec",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:02.8501087-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:02.8497556-06:00"
   },
   "source": [
    "You can also create arrays using the range operator `..`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "000ad7b4",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:02.9179676-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:02.8501369-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// start..end (both inclusive)\n",
    "[| 1 .. 10 |]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>[ 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5 ]</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "//   ..step..\n",
    "[| 5 .. -1 .. -5 |]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5a5fc89",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:02.9183385-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:02.9179925-06:00"
   },
   "source": [
    "or by using sequence expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a8e11aa8",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:02.9924665-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:02.9183531-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>[ 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 ]</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "[| for i in 1..10 -> i * i |]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5531a00",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:02.992825-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:02.9924931-06:00"
   },
   "source": [
    "Let's use them together to plot the array of integer squares up to 10:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "77b5651c",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:03.0172459-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:02.9928392-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div id=\"c6d83387-24ad-4aaf-ad7b-1b6ed23f1693\"><!-- Plotly chart will be drawn inside this DIV --></div><script type=\"text/javascript\">\n",
       "var renderPlotly_c6d8338724ad4aafad7b1b6ed23f1693 = function() {\n",
       "    var fsharpPlotlyRequire = requirejs.config({context:'fsharp-plotly',paths:{plotly:'https://cdn.plot.ly/plotly-2.27.1.min'}}) || require;\n",
       "    fsharpPlotlyRequire(['plotly'], function(Plotly) {\n",
       "        var data = [{\"type\":\"scatter\",\"mode\":\"lines\",\"x\":[1,2,3,4,5,6,7,8,9,10],\"y\":[1,4,9,16,25,36,49,64,81,100],\"marker\":{},\"line\":{}}];\n",
       "        var layout = {\"width\":0,\"height\":400,\"template\":{\"layout\":{\"margin\":{\"l\":30.0,\"r\":30.0,\"t\":30.0,\"b\":30.0},\"autosize\":true},\"data\":{}}};\n",
       "        var config = {\"responsive\":true};\n",
       "        Plotly.newPlot('c6d83387-24ad-4aaf-ad7b-1b6ed23f1693', data, layout, config);\n",
       "    });\n",
       "};\n",
       "if ((typeof(requirejs) !==  typeof(Function)) || (typeof(requirejs.config) !== typeof(Function))) {\n",
       "    var script = document.createElement(\"script\");\n",
       "    script.setAttribute(\"charset\", \"utf-8\");\n",
       "    script.setAttribute(\"src\", \"https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.6/require.min.js\");\n",
       "    script.onload = function(){\n",
       "        renderPlotly_c6d8338724ad4aafad7b1b6ed23f1693();\n",
       "    };\n",
       "    document.getElementsByTagName(\"head\")[0].appendChild(script);\n",
       "}\n",
       "else {\n",
       "    renderPlotly_c6d8338724ad4aafad7b1b6ed23f1693();\n",
       "}\n",
       "</script></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "open Plotly.NET\n",
    "\n",
    "Chart.Line([| for x in 1 .. 10 -> x, x * x |])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57093f7e",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:03.0176744-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:03.0172763-06:00"
   },
   "source": [
    "# [Functions](#Functions)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6975913a",
   "metadata": {},
   "source": [
    "In math, elements belong to one or more sets, and functions map elements between those sets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "332d146a",
   "metadata": {},
   "source": [
    "Here is a function that maps an element $x$ to itself plus 2:\n",
    "$$f(x) = x + 2$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8810b35",
   "metadata": {},
   "source": [
    "We didn't write out the sets that $f$ maps elements between. We can just infer that information based on how $x$ is used in $f$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "745df52a",
   "metadata": {},
   "source": [
    "That information is still there though. If we wanted to specifically say $f$ maps an integer to an integer, we could write a domain constraint:\n",
    "$$f(x) : \\mathbb{Z} \\rightarrow \\mathbb{Z}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d4948d2",
   "metadata": {},
   "source": [
    "We could write a function resembling $f$ in F# like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6fd9ba97",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "fun (x: int) -> (x + 2): int"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da8c3828",
   "metadata": {},
   "source": [
    "Here, we take `x` (an `int`) and add `2` (an `int`) to it which evaluates to `x + 2` (also an `int`)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81bc246f",
   "metadata": {},
   "source": [
    "`int` works kind of like $\\mathbb{Z}$ here:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3c7e7f0",
   "metadata": {},
   "source": [
    "<div style=\"text-align: center; margin: auto;\">\n",
    "\n",
    "![An image demonstrating a function that maps from `int` to `int`.](media/functions1.png \"int Function\")\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59af46b4",
   "metadata": {},
   "source": [
    "Similar to our first $f$, we can omit the keyword `int`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cdb1809b",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "fun x -> x + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f27cd78",
   "metadata": {},
   "source": [
    "It looks like the types just vanished 👻! But I assure you they're still there."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40860170",
   "metadata": {},
   "source": [
    "The F# compiler sees we added an `int` to `x`, and *infers* that `x` must be an `int`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cfb1062",
   "metadata": {},
   "source": [
    "We can't see it yet, but the F# compiler also inferred that our function itself has a type `int -> int`, because it takes an `int` and evaluates to an `int`. We can demonstrate its type by *applying* an `int` to our function and seeing that we get an `int` back out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f6e490c1",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(fun x -> x + 2) 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4443188a",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>ℹ️ Note for C# developers</summary>\n",
    "\n",
    "> `int -> int` is an F# type, but what does this look like when compiled to an assembly? F# types are a superset of .NET types. All .NET types can be represented in F# but F# function types compile to **`FSharpFunc`**. Reading on to [Partial Application](#Partial-Application) and taking a look at some [F# decompiled to C#](https://sharplab.io/#v2:DYLgZgzgPsCmAuACAhgE1YgHognogvFogNS4CwAUJXEmqgMy4ErqL1A=) explains why.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd77ddcf",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:03.0484795-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:03.0481759-06:00"
   },
   "source": [
    "# [`let` Bindings](#let-Bindings)\n",
    "\n",
    "Functions allow us to create **scopes** (the `()`s) wherein we can assign names to values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1764c1c0",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:03.0531191-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:03.0485104-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(fun x ->   // name in (\n",
    "    x + 2   //      scope\n",
    ") 3         // ) = value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb740954",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:03.0534527-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:03.0531412-06:00"
   },
   "source": [
    "We can rewrite this use of a function with a **`let` binding**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1161423a",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let x = 3 in   // name = value in (\n",
    "    x + 2      //   scope\n",
    "               // )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd638d62",
   "metadata": {},
   "source": [
    "These two pieces of code effectively represent the same thing in F#.\n",
    "\n",
    "The `in` and indentation are used to explicitly define the scope where `x` is defined. If you want a binding to be defined for as long as possible (up until the parent scope ends), you can leave out the `in` and indentation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8ecb985c",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let y = 2 in\n",
    "    let x = 3\n",
    "    x + y // `x` is defined here\n",
    "// `x` is not defined here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6a08f6a",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:03.1012845-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:03.1009263-06:00"
   },
   "source": [
    "Assigning a name to an expression in F# is called a **binding**, because the value can't change once set. Using `=` without a `let` compares the equality of two objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "412ba4e2",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:03.108468-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:03.1013003-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>False</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let a = 3\n",
    "a = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d856c80",
   "metadata": {
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:03.0753349-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:03.0750174-06:00"
   },
   "source": [
    "# [Partial Application](#Partial-Application)\n",
    "\n",
    "We can move the body up into the same line with `in`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "db9c1da9",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "dotnet_repl_cellExecutionEndTime": "2024-02-29T00:56:03.0888679-06:00",
    "dotnet_repl_cellExecutionStartTime": "2024-02-29T00:56:03.0753441-06:00",
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let x = 3 in x + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c2f85a5",
   "metadata": {},
   "source": [
    "And assign the whole `let` expression to another one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a763fc8e",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let five = let x = 3 in x + 2\n",
    "five"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca05d5b6",
   "metadata": {},
   "source": [
    "Rewriting our inner `let` binding back to a `fun` looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5b2a4066",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let five = (fun x -> x + 2) 3\n",
    "five"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e42637f7",
   "metadata": {},
   "source": [
    "We can remove the `3` to delay binding the parameter to our function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "8d4c971c",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let add2 = fun x -> x + 2\n",
    "add2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88135532",
   "metadata": {},
   "source": [
    "We can rewrite the above function by moving `x` to the left of the `=`. This results in the same behavior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "84589a4a",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let add2 x = x + 2\n",
    "add2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd40f301",
   "metadata": {},
   "source": [
    "We can replace `x + 2` with another `fun`, one that introduces a parameter `y` and uses it in tandem with `x` (this is called **closure**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0ded55dc",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let add x = fun y -> x + y\n",
    "add 3 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df519a8f",
   "metadata": {},
   "source": [
    "We can also move `y` to the left of `=`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "23dc6607",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let add x y = x + y\n",
    "add 3 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69664fdd",
   "metadata": {},
   "source": [
    "Practically, we've come across a function `add` that can take not just one parameter, but two! It may not surprise you that we can keep repeating this process to allow for many parameters. However, under the hood, we can treat functions that take multiple parameters like `add` as if they were recursively enclosing `fun`s, which means we can bind them to names without applying every single one of their parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "42545f17",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>5</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let add2 = add 2\n",
    "add2 3 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "215f5f1e",
   "metadata": {},
   "source": [
    "This feature is called **partial application**. It can help you express complexity using simple, modular pieces:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80ae388c",
   "metadata": {},
   "source": [
    "Here we build `add` and `divide` from `combine` by passing `+` and `/` to it. This code doesn't do much anything useful though... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a6300a67",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<details open=\"open\" class=\"dni-treeview\"><summary><span class=\"dni-code-hint\"><code>(7, 2)</code></span></summary><div><table><thead><tr></tr></thead><tbody><tr><td>Item1</td><td><div class=\"dni-plaintext\"><pre>7</pre></div></td></tr><tr><td>Item2</td><td><div class=\"dni-plaintext\"><pre>2</pre></div></td></tr></tbody></table></div></details><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// y applied to x applied to f\n",
    "let combine f x y = f x y\n",
    "let add = combine (+) // a way to pass the + function\n",
    "let divide = combine (/)\n",
    "\n",
    "add 3 4, divide 9 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bbb29e9",
   "metadata": {},
   "source": [
    "We can pass a `check` function to `combine` that can perform a check and decide whether we want to continue the computation or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ae36a578",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "let combine f check x y =\n",
    "    check f x y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49329736",
   "metadata": {},
   "source": [
    "We can build all different kinds of \"adders\" from `combine`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "265d4712",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "let normalize f x y = f (abs x) (abs y)\n",
    "\n",
    "let normalizeThenAdd = combine (+) normalize\n",
    "normalizeThenAdd -4 5 |> printfn \"%d\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "b139cf27",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding 5 + 6...\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "let printThenAdd = combine (+) (fun f x y -> printfn \"Adding %d + %d...\" x y; f x y)\n",
    "printThenAdd 5 6 |> printfn \"%d\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "972d1981",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "let add = combine (+) id // id is a special function that means \"do nothing\" in this context\n",
    "add 3 5 |> printfn \"%d\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c89cc9d",
   "metadata": {},
   "source": [
    "We can build \"safe dividers\" that check when the denominator = 0 and change behavior in response."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ca4528b",
   "metadata": {},
   "source": [
    "`safeDivide` replaces `y` with `NaN` when `y = 0`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "04e1b925",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NaN\n"
     ]
    }
   ],
   "source": [
    "let ``convert divBy0 to NaN`` f x y =\n",
    "    f x (if y = 0 then nan else y)\n",
    "\n",
    "let safeDivide = combine (/) ``convert divBy0 to NaN``\n",
    "safeDivide 4 0 |> printfn \"%f\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12c206eb",
   "metadata": {},
   "source": [
    "`safeDivide` implicitly evaluates to a `float`, though, because `NaN` is not a valid value for `int`s. Sometimes you absolutely do want integer division, which evaluates to an `int` and ignores the remainder.\n",
    "\n",
    "`tryDivide` checks if `y = 0`, and if it is, it avoids doing the division altogether (by not evaluating `cont`).\n",
    "> ℹ️ Note\n",
    "> \n",
    "> I should move this example down further to when I explain Option types, perhaps referencing this example. It is not 100% clear what is going on here without explaining option types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "80a311f3",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some(4)\n",
      "<null>\n"
     ]
    }
   ],
   "source": [
    "let ``convert divBy0 to None`` cont x y =\n",
    "    if y = 0 then None else Some(cont x y)\n",
    "\n",
    "// remove this example for now and reference it when teaching the Option type\n",
    "let tryDivide = combine (/) ``convert divBy0 to None``\n",
    "\n",
    "tryDivide 4 1 |> printfn \"%O\"\n",
    "tryDivide 4 0 |> printfn \"%O\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ec9b1fa",
   "metadata": {},
   "source": [
    "# [Types](#Types)\n",
    "\n",
    "F# is different from languages like Python and JavaScript in that it has a strong opinion on what is a **type**.\n",
    "\n",
    "Types are rules that the compiler (what checks and builds your code) uses to check you're writing a correct program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cbca192",
   "metadata": {},
   "source": [
    "Let's start with a simple exercise comparing with Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "bdf8b6ed",
   "metadata": {
    "dotnet_interactive": {
     "language": "value"
    },
    "polyglot_notebook": {
     "kernelName": "value"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "The `#!connect jupyter` feature is in preview. Please report any feedback or issues at https://github.com/dotnet/interactive/issues/new/choose."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Kernel added: #!pythonkernel"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#!connect jupyter --kernel-name pythonkernel --conda-env base --kernel-spec python3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59986e33",
   "metadata": {},
   "source": [
    "We create a function that prints the combined age of two people:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "da794ddf",
   "metadata": {
    "dotnet_interactive": {
     "language": "pythonkernel"
    },
    "polyglot_notebook": {
     "kernelName": "pythonkernel"
    }
   },
   "outputs": [],
   "source": [
    "def add_person_age(person1, person2):\n",
    "    print(f\"{person1.name} and {person2.name}'s combined age is {person1.age + person2.age}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d2c031e",
   "metadata": {},
   "source": [
    "We construct two objects that each contain the attributes our function uses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "447b2640",
   "metadata": {
    "dotnet_interactive": {
     "language": "pythonkernel"
    },
    "polyglot_notebook": {
     "kernelName": "pythonkernel"
    }
   },
   "outputs": [],
   "source": [
    "# using the type function\n",
    "person1 = type(\"\", (), {})\n",
    "person1.name, person1.age = \"Rebecca\", 23\n",
    "\n",
    "# using a class\n",
    "class Person:\n",
    "    # optionally write an __init__ function to instead pass attribute values to a constructor\n",
    "    pass\n",
    "person2 = Person()\n",
    "person2.name, person2.age = \"Eric\", 27"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f536a45f",
   "metadata": {},
   "source": [
    "And then call the function with our objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "15781957",
   "metadata": {
    "dotnet_interactive": {
     "language": "pythonkernel"
    },
    "polyglot_notebook": {
     "kernelName": "pythonkernel"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rebecca and Eric's combined age is 50\n"
     ]
    }
   ],
   "source": [
    "add_person_age(person1, person2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c7524a36",
   "metadata": {
    "dotnet_interactive": {
     "language": "pythonkernel"
    },
    "polyglot_notebook": {
     "kernelName": "pythonkernel"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\r\n",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)\r\n",
      "Cell \u001b[1;32mIn[1], line 5\u001b[0m\n",
      "\u001b[0;32m      2\u001b[0m person3\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEric\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
      "\u001b[0;32m      3\u001b[0m \u001b[38;5;66;03m# oops we forgot to assign Age...\u001b[39;00m\n",
      "\u001b[0;32m      4\u001b[0m \u001b[38;5;66;03m# ❌ this code compiles but fails in the function call ⬇️ when trying to add an Age of None\u001b[39;00m\n",
      "\u001b[1;32m----> 5\u001b[0m \u001b[43madd_person_age\u001b[49m\u001b[43m(\u001b[49m\u001b[43mperson1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mperson3\u001b[49m\u001b[43m)\u001b[49m\n",
      "\r\n",
      "Cell \u001b[1;32mIn[1], line 2\u001b[0m, in \u001b[0;36madd_person_age\u001b[1;34m(person1, person2)\u001b[0m\n",
      "\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21madd_person_age\u001b[39m(person1, person2):\n",
      "\u001b[1;32m----> 2\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mperson1\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m and \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mperson2\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ms combined age is \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mperson1\u001b[38;5;241m.\u001b[39mage\u001b[38;5;250m \u001b[39m\u001b[38;5;241m+\u001b[39m\u001b[38;5;250m \u001b[39m\u001b[43mperson2\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mage\u001b[49m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n",
      "\r\n",
      "\u001b[1;31mAttributeError\u001b[0m: type object '' has no attribute 'age'\r\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "AttributeError",
     "output_type": "error",
     "traceback": [
      "AttributeError"
     ]
    }
   ],
   "source": [
    "person3 = type(\"\", (), {})\n",
    "person3.name = \"Eric\"\n",
    "# oops we forgot to assign Age...\n",
    "# ❌ this code compiles but fails in the function call ⬇️ when trying to add an Age of None\n",
    "add_person_age(person1, person3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ea0bb1e",
   "metadata": {},
   "source": [
    "We know that invoking `add_person_age(person1, person3)` will *always* error before executing. However, the error isn't thrown until we actually run our code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edfa32f1",
   "metadata": {},
   "source": [
    "Let's write one possible F# alternative:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "96a3cceb",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "let inline addPersonAge person1 person2 =\n",
    "    printfn \"%s and %s's combined age is %d\"\n",
    "        (^T: (member Name : string) person1)\n",
    "        (^U: (member Name : string) person2)\n",
    "        ((^T: (member Age : int) person1) + (^U: (member Age : int) person2))  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4be5dd52",
   "metadata": {},
   "source": [
    "`^T: (member Name : string)` is called a **type constraint**. When applied to `person1`, it's the same as accessing `person1.Name` but also tells the F# compiler that `person1` has to have a `Name` of type `string`.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98014328",
   "metadata": {},
   "source": [
    "We can evaluate `addPersonAge` with [**anonymous records**](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/anonymous-records):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b9395ef4",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rebecca and Eric's combined age is 50\n"
     ]
    }
   ],
   "source": [
    "addPersonAge\n",
    "    {| Name = \"Rebecca\"; Age = 23 |}\n",
    "    {| Name = \"Eric\"; Age = 27 |}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "74c7a447",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Stopped due to error\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "input.fsx (4,5)-(4,24) typecheck error The type '{| Name: string |}' does not support the operator 'get_Age'. See also input.fsx(2,0)-(2,12).",
     "output_type": "error",
     "traceback": [
      "input.fsx (4,5)-(4,24) typecheck error The type '{| Name: string |}' does not support the operator 'get_Age'. See also input.fsx(2,0)-(2,12)."
     ]
    }
   ],
   "source": [
    "// ❌ this code does not compile\n",
    "addPersonAge\n",
    "    {| Name = \"Rebecca\"; Age = 23 |}\n",
    "    {| Name = \"Eric\" |} // oops... we forgot to add `Age`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6431e1d",
   "metadata": {},
   "source": [
    "This feature is called **Statically Resolved Type Parameters**. It's pretty useful for when you want to make assertions about the data your function accepts, but you'd like to write your function in a way that accepts all kinds of data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fab403f",
   "metadata": {},
   "source": [
    "For example, Jonny's record has an additional property below, but we can still use it with `addPersonAge` because it satisfies the necessary type constraints (`requires member Name and member Age`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "c7fc4476",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rebecca and Jonny's combined age is 57\n"
     ]
    }
   ],
   "source": [
    "addPersonAge\n",
    "    {| Name = \"Rebecca\"; Age = 23 |}\n",
    "    {| Name = \"Jonny\"; Age = 34; IsAdmin = true |}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6906067",
   "metadata": {},
   "source": [
    "We can make the body of `addPersonAge` more concise by moving the type constraints to the function signature:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "d81777d8",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "let inline addPersonAge<'T, 'U\n",
    "    when 'T : (member Name : string)\n",
    "    and 'T : (member Age : int)\n",
    "    and 'U : (member Name : string)\n",
    "    and 'U : (member Age : int)>(person1: 'T) (person2: 'U) =\n",
    "    printfn \"%s and %s's combined age is %d\"\n",
    "        person1.Name\n",
    "        person2.Name\n",
    "        (person1.Age + person2.Age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ff35a2c",
   "metadata": {},
   "source": [
    "However... in turn, it makes the function signature a little cluttered..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bb1716c",
   "metadata": {},
   "source": [
    "When we have control of our source data, it's often better to use explicit **types**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "0bc65d32",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "type Person = {\n",
    "    Name : string\n",
    "    Age : int\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e58930cf",
   "metadata": {},
   "source": [
    "The following code creates a `person1` of type `Person`, which denotes that `person1` has the exact *shape* of `Person`, no more members, no fewer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "38984d63",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "let person1 : Person = { Name = \"Rebecca\"; Age = 23 }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78683e05",
   "metadata": {},
   "source": [
    "The `: Person` is called the **type signature**. It's often not needed, which we can demonstrate with our new `addPersonAge`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "1ee42d11",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rebecca and Rebecca's combined age is 46\n"
     ]
    }
   ],
   "source": [
    "let addPersonAge person1 person2 =\n",
    "    printfn \"%s and %s's combined age is %d\"\n",
    "        person1.Name\n",
    "        person2.Name\n",
    "        (person1.Age + person2.Age)\n",
    "\n",
    "addPersonAge { Name = \"Rebecca\"; Age = 23 } { Name = \"Rebecca\"; Age = 23 }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a7e99c8",
   "metadata": {},
   "source": [
    "Just because we didn't have to write the type doesn't mean it's not there. The compiler looks at how we used the parameter and infers the type. This is - perhaps unsurprisingly - called **type inference**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b21b4f0",
   "metadata": {},
   "source": [
    "## [Type Providers](#Type-Providers)\n",
    "\n",
    "We *did* still have to define the structure of `Person` up front though. This is called **domain modeling**, and it's useful when you are writing an application [Type Providers](#type-providers) to model a business function and want to reduce number of possible error states to a minimum.\n",
    "\n",
    "Sometimes, however, we're not writing an application but instead writing a script that deals with large amounts of data, and our stupid mistakes might come from accidentally misinterpreting the structure of our data.\n",
    "\n",
    "F# has a feature for this called **type providers**. Whenever we're dealing with external data imports, type providers create a type for us based on the structure of the data we're importing, meaning we don't have to manually create types for huge data sets and our data and types never get out of sync."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73d89f53",
   "metadata": {},
   "source": [
    "Here's a quick example using the FSharp.Data WorldBank type provider that I took from [their documentation](https://fsprojects.github.io/FSharp.Data/library/WorldBank.html#Using-World-Bank-data-asynchronously):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "3ac5b4af",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div></div><div></div><div><strong>Installed Packages</strong><ul><li><span>FSharp.Data, 6.4.0</span></li></ul></div></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<details open=\"open\" class=\"dni-treeview\"><summary><span class=\"dni-code-hint\"><code>(2023, 17.7531439952426)</code></span></summary><div><table><thead><tr></tr></thead><tbody><tr><td>Item1</td><td><div class=\"dni-plaintext\"><pre>2023</pre></div></td></tr><tr><td>Item2</td><td><div class=\"dni-plaintext\"><pre>17.7531439952426</pre></div></td></tr></tbody></table></div></details><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#r \"nuget: FSharp.Data\"\n",
    "\n",
    "open FSharp.Data\n",
    "\n",
    "let data = WorldBankData.GetDataContext()\n",
    "\n",
    "data.Countries.``United Kingdom``.Indicators.``Gross capital formation (% of GDP)``\n",
    "|> Seq.maxBy fst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1e11a85",
   "metadata": {},
   "source": [
    "The WorldBank provider is a premade example where a type is specifically created and republished using a well-known data source. But we can also use \"data type\" (CSV, JSON, SQL, etc.,) type providers to create types for our own data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "7ea6ebd9",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div id=\"5d2dd2b9-177b-4f94-b81d-9aceb5716cd8\"><!-- Plotly chart will be drawn inside this DIV --></div><script type=\"text/javascript\">\n",
       "var renderPlotly_5d2dd2b9177b4f94b81d9aceb5716cd8 = function() {\n",
       "    var fsharpPlotlyRequire = requirejs.config({context:'fsharp-plotly',paths:{plotly:'https://cdn.plot.ly/plotly-2.27.1.min'}}) || require;\n",
       "    fsharpPlotlyRequire(['plotly'], function(Plotly) {\n",
       "        var data = [{\"type\":\"scatter\",\"mode\":\"lines\",\"x\":[\"2023-03-06T00:00:00-06:00\",\"2023-03-07T00:00:00-06:00\",\"2023-03-08T00:00:00-06:00\",\"2023-03-09T00:00:00-06:00\",\"2023-03-10T00:00:00-06:00\",\"2023-03-13T00:00:00-05:00\",\"2023-03-14T00:00:00-05:00\",\"2023-03-15T00:00:00-05:00\",\"2023-03-16T00:00:00-05:00\",\"2023-03-17T00:00:00-05:00\",\"2023-03-20T00:00:00-05:00\",\"2023-03-21T00:00:00-05:00\",\"2023-03-22T00:00:00-05:00\",\"2023-03-23T00:00:00-05:00\",\"2023-03-24T00:00:00-05:00\",\"2023-03-27T00:00:00-05:00\",\"2023-03-28T00:00:00-05:00\",\"2023-03-29T00:00:00-05:00\",\"2023-03-30T00:00:00-05:00\",\"2023-03-31T00:00:00-05:00\",\"2023-04-03T00:00:00-05:00\",\"2023-04-04T00:00:00-05:00\",\"2023-04-05T00:00:00-05:00\",\"2023-04-06T00:00:00-05:00\",\"2023-04-10T00:00:00-05:00\",\"2023-04-11T00:00:00-05:00\",\"2023-04-12T00:00:00-05:00\",\"2023-04-13T00:00:00-05:00\",\"2023-04-14T00:00:00-05:00\",\"2023-04-17T00:00:00-05:00\",\"2023-04-18T00:00:00-05:00\",\"2023-04-19T00:00:00-05:00\",\"2023-04-20T00:00:00-05:00\",\"2023-04-21T00:00:00-05:00\",\"2023-04-24T00:00:00-05:00\",\"2023-04-25T00:00:00-05:00\",\"2023-04-26T00:00:00-05:00\",\"2023-04-27T00:00:00-05:00\",\"2023-04-28T00:00:00-05:00\",\"2023-05-01T00:00:00-05:00\",\"2023-05-02T00:00:00-05:00\",\"2023-05-03T00:00:00-05:00\",\"2023-05-04T00:00:00-05:00\",\"2023-05-05T00:00:00-05:00\",\"2023-05-08T00:00:00-05:00\",\"2023-05-09T00:00:00-05:00\",\"2023-05-10T00:00:00-05:00\",\"2023-05-11T00:00:00-05:00\",\"2023-05-12T00:00:00-05:00\",\"2023-05-15T00:00:00-05:00\",\"2023-05-16T00:00:00-05:00\",\"2023-05-17T00:00:00-05:00\",\"2023-05-18T00:00:00-05:00\",\"2023-05-19T00:00:00-05:00\",\"2023-05-22T00:00:00-05:00\",\"2023-05-23T00:00:00-05:00\",\"2023-05-24T00:00:00-05:00\",\"2023-05-25T00:00:00-05:00\",\"2023-05-26T00:00:00-05:00\",\"2023-05-30T00:00:00-05:00\",\"2023-05-31T00:00:00-05:00\",\"2023-06-01T00:00:00-05:00\",\"2023-06-02T00:00:00-05:00\",\"2023-06-05T00:00:00-05:00\",\"2023-06-06T00:00:00-05:00\",\"2023-06-07T00:00:00-05:00\",\"2023-06-08T00:00:00-05:00\",\"2023-06-09T00:00:00-05:00\",\"2023-06-12T00:00:00-05:00\",\"2023-06-13T00:00:00-05:00\",\"2023-06-14T00:00:00-05:00\",\"2023-06-15T00:00:00-05:00\",\"2023-06-16T00:00:00-05:00\",\"2023-06-20T00:00:00-05:00\",\"2023-06-21T00:00:00-05:00\",\"2023-06-22T00:00:00-05:00\",\"2023-06-23T00:00:00-05:00\",\"2023-06-26T00:00:00-05:00\",\"2023-06-27T00:00:00-05:00\",\"2023-06-28T00:00:00-05:00\",\"2023-06-29T00:00:00-05:00\",\"2023-06-30T00:00:00-05:00\",\"2023-07-03T00:00:00-05:00\",\"2023-07-05T00:00:00-05:00\",\"2023-07-06T00:00:00-05:00\",\"2023-07-07T00:00:00-05:00\",\"2023-07-10T00:00:00-05:00\",\"2023-07-11T00:00:00-05:00\",\"2023-07-12T00:00:00-05:00\",\"2023-07-13T00:00:00-05:00\",\"2023-07-14T00:00:00-05:00\",\"2023-07-17T00:00:00-05:00\",\"2023-07-18T00:00:00-05:00\",\"2023-07-19T00:00:00-05:00\",\"2023-07-20T00:00:00-05:00\",\"2023-07-21T00:00:00-05:00\",\"2023-07-24T00:00:00-05:00\",\"2023-07-25T00:00:00-05:00\",\"2023-07-26T00:00:00-05:00\",\"2023-07-27T00:00:00-05:00\",\"2023-07-28T00:00:00-05:00\",\"2023-07-31T00:00:00-05:00\",\"2023-08-01T00:00:00-05:00\",\"2023-08-02T00:00:00-05:00\",\"2023-08-03T00:00:00-05:00\",\"2023-08-04T00:00:00-05:00\",\"2023-08-07T00:00:00-05:00\",\"2023-08-08T00:00:00-05:00\",\"2023-08-09T00:00:00-05:00\",\"2023-08-10T00:00:00-05:00\",\"2023-08-11T00:00:00-05:00\",\"2023-08-14T00:00:00-05:00\",\"2023-08-15T00:00:00-05:00\",\"2023-08-16T00:00:00-05:00\",\"2023-08-17T00:00:00-05:00\",\"2023-08-18T00:00:00-05:00\",\"2023-08-21T00:00:00-05:00\",\"2023-08-22T00:00:00-05:00\",\"2023-08-23T00:00:00-05:00\",\"2023-08-24T00:00:00-05:00\",\"2023-08-25T00:00:00-05:00\",\"2023-08-28T00:00:00-05:00\",\"2023-08-29T00:00:00-05:00\",\"2023-08-30T00:00:00-05:00\",\"2023-08-31T00:00:00-05:00\",\"2023-09-01T00:00:00-05:00\",\"2023-09-05T00:00:00-05:00\",\"2023-09-06T00:00:00-05:00\",\"2023-09-07T00:00:00-05:00\",\"2023-09-08T00:00:00-05:00\",\"2023-09-11T00:00:00-05:00\",\"2023-09-12T00:00:00-05:00\",\"2023-09-13T00:00:00-05:00\",\"2023-09-14T00:00:00-05:00\",\"2023-09-15T00:00:00-05:00\",\"2023-09-18T00:00:00-05:00\",\"2023-09-19T00:00:00-05:00\",\"2023-09-20T00:00:00-05:00\",\"2023-09-21T00:00:00-05:00\",\"2023-09-22T00:00:00-05:00\",\"2023-09-25T00:00:00-05:00\",\"2023-09-26T00:00:00-05:00\",\"2023-09-27T00:00:00-05:00\",\"2023-09-28T00:00:00-05:00\",\"2023-09-29T00:00:00-05:00\",\"2023-10-02T00:00:00-05:00\",\"2023-10-03T00:00:00-05:00\",\"2023-10-04T00:00:00-05:00\",\"2023-10-05T00:00:00-05:00\",\"2023-10-06T00:00:00-05:00\",\"2023-10-09T00:00:00-05:00\",\"2023-10-10T00:00:00-05:00\",\"2023-10-11T00:00:00-05:00\",\"2023-10-12T00:00:00-05:00\",\"2023-10-13T00:00:00-05:00\",\"2023-10-16T00:00:00-05:00\",\"2023-10-17T00:00:00-05:00\",\"2023-10-18T00:00:00-05:00\",\"2023-10-19T00:00:00-05:00\",\"2023-10-20T00:00:00-05:00\",\"2023-10-23T00:00:00-05:00\",\"2023-10-24T00:00:00-05:00\",\"2023-10-25T00:00:00-05:00\",\"2023-10-26T00:00:00-05:00\",\"2023-10-27T00:00:00-05:00\",\"2023-10-30T00:00:00-05:00\",\"2023-10-31T00:00:00-05:00\",\"2023-11-01T00:00:00-05:00\",\"2023-11-02T00:00:00-05:00\",\"2023-11-03T00:00:00-05:00\",\"2023-11-06T00:00:00-06:00\",\"2023-11-07T00:00:00-06:00\",\"2023-11-08T00:00:00-06:00\",\"2023-11-09T00:00:00-06:00\",\"2023-11-10T00:00:00-06:00\",\"2023-11-13T00:00:00-06:00\",\"2023-11-14T00:00:00-06:00\",\"2023-11-15T00:00:00-06:00\",\"2023-11-16T00:00:00-06:00\",\"2023-11-17T00:00:00-06:00\",\"2023-11-20T00:00:00-06:00\",\"2023-11-21T00:00:00-06:00\",\"2023-11-22T00:00:00-06:00\",\"2023-11-24T00:00:00-06:00\",\"2023-11-27T00:00:00-06:00\",\"2023-11-28T00:00:00-06:00\",\"2023-11-29T00:00:00-06:00\",\"2023-11-30T00:00:00-06:00\",\"2023-12-01T00:00:00-06:00\",\"2023-12-04T00:00:00-06:00\",\"2023-12-05T00:00:00-06:00\",\"2023-12-06T00:00:00-06:00\",\"2023-12-07T00:00:00-06:00\",\"2023-12-08T00:00:00-06:00\",\"2023-12-11T00:00:00-06:00\",\"2023-12-12T00:00:00-06:00\",\"2023-12-13T00:00:00-06:00\",\"2023-12-14T00:00:00-06:00\",\"2023-12-15T00:00:00-06:00\",\"2023-12-18T00:00:00-06:00\",\"2023-12-19T00:00:00-06:00\",\"2023-12-20T00:00:00-06:00\",\"2023-12-21T00:00:00-06:00\",\"2023-12-22T00:00:00-06:00\",\"2023-12-26T00:00:00-06:00\",\"2023-12-27T00:00:00-06:00\",\"2023-12-28T00:00:00-06:00\",\"2023-12-29T00:00:00-06:00\",\"2024-01-02T00:00:00-06:00\",\"2024-01-03T00:00:00-06:00\",\"2024-01-04T00:00:00-06:00\",\"2024-01-05T00:00:00-06:00\",\"2024-01-08T00:00:00-06:00\",\"2024-01-09T00:00:00-06:00\",\"2024-01-10T00:00:00-06:00\",\"2024-01-11T00:00:00-06:00\",\"2024-01-12T00:00:00-06:00\",\"2024-01-16T00:00:00-06:00\",\"2024-01-17T00:00:00-06:00\",\"2024-01-18T00:00:00-06:00\",\"2024-01-19T00:00:00-06:00\",\"2024-01-22T00:00:00-06:00\",\"2024-01-23T00:00:00-06:00\",\"2024-01-24T00:00:00-06:00\",\"2024-01-25T00:00:00-06:00\",\"2024-01-26T00:00:00-06:00\",\"2024-01-29T00:00:00-06:00\",\"2024-01-30T00:00:00-06:00\",\"2024-01-31T00:00:00-06:00\",\"2024-02-01T00:00:00-06:00\",\"2024-02-02T00:00:00-06:00\",\"2024-02-05T00:00:00-06:00\",\"2024-02-06T00:00:00-06:00\",\"2024-02-07T00:00:00-06:00\",\"2024-02-08T00:00:00-06:00\",\"2024-02-09T00:00:00-06:00\",\"2024-02-12T00:00:00-06:00\",\"2024-02-13T00:00:00-06:00\",\"2024-02-14T00:00:00-06:00\",\"2024-02-15T00:00:00-06:00\",\"2024-02-16T00:00:00-06:00\",\"2024-02-20T00:00:00-06:00\",\"2024-02-21T00:00:00-06:00\",\"2024-02-22T00:00:00-06:00\",\"2024-02-23T00:00:00-06:00\",\"2024-02-26T00:00:00-06:00\",\"2024-02-27T00:00:00-06:00\",\"2024-02-28T00:00:00-06:00\",\"2024-02-29T00:00:00-06:00\",\"2024-03-01T00:00:00-06:00\",\"2024-03-04T00:00:00-06:00\",\"2024-03-05T00:00:00-06:00\",\"2024-03-06T00:00:00-06:00\"],\"y\":[4.139999,4.300003,3.729995,7.979996,5.189987,12.180008,5.210006,7.270020,13.279999,7.009980,7.630005,5.480011,8.860016,5.859986,5.350006,5.940002,4.090027,2.730011,2.979980,6.269989,4.319977,4.779999,4.229981,10.049988,4.890015,4.339996,5.050019,6.729981,4.790009,5.440002,4.750000,4.509979,3.950012,3.209991,6.230011,6.230011,6.839996,9.950012,5.619995,3.450012,5.269989,4.519989,4.360016,7.700012,4.110016,3.730011,5.329987,4.859985,4.049988,2.309998,3.880004,3.690003,5.320008,2.380005,4.579986,7.470001,3.890015,6.899994,9.519989,5.220001,8.610015,8.809998,4.950012,3.899994,3.199982,11.989990,3.290009,5.579986,6.940002,6.589996,6.230011,12.639984,9.519989,6.220002,5.660004,6.779999,4.509979,7.619995,6.850006,4.170013,3.489990,5.529999,4.329987,6.919983,7.489990,4.790009,7.640015,5.859985,5.979981,4.720001,7.119995,4.789978,24.609986,10.019989,12.600006,10.470001,4.610015,6.820008,11.560028,12.279999,6.839997,4.340027,4.839997,7.270020,3.929993,7.900025,3.589996,5.750000,6.059997,7.080017,3.200013,3.980011,4.190002,4.620025,5.660004,6.830017,5.729980,4.619996,5.740021,13.020020,6.559997,4.429993,7.100006,3.359986,4.130005,5.209991,6.190002,4.279998,4.049988,6.700013,2.990020,5.309998,5.679993,4.289978,7.750000,4.040009,4.880005,9.079986,10.350006,5.300018,2.670013,5.860016,4.609986,6.029999,4.489990,6.710022,10.180024,6.040009,5.080017,12.890014,7.119995,3.429993,3.679992,4.910004,7.470002,5.540009,6.049987,7.290008,5.970001,6.470001,8.339996,4.239990,8.580017,14.690003,8.320007,7.620025,4.309998,7.770019,4.059998,7.060028,4.190003,4.829986,3.320007,4.430024,9.029999,2.570007,4.600006,6.020020,6.170013,7.369995,7.869995,5.100006,4.820008,2.829986,4.440003,4.839996,6.859986,4.619995,6.850006,6.619995,7.459992,6.149994,5.130005,6.229980,5.500000,3.960022,6.870026,9.630005,6.119995,4.320007,3.420014,5.500000,4.369995,2.470002,3.440002,2.250000,2.299987,3.679993,9.130005,4.750000,5.929993,5.559998,6.190002,4.799988,7.850006,10.299988,4.029999,6.410004,5.299987,3.869995,5.170013,7.029999,5.450012,5.179993,4.480011,3.740020,5.650024,6.599976,18.110016,6.200012,9.089996,7.170014,5.059997,6.899994,3.029999,5.730011,5.989990,6.679992,5.269989,4.839996,4.850007,6.479980,5.070008,4.259980,6.889984,4.800019,4.470001,3.979981,8.279999,4.989990,5.029999,13.609985,6.769989],\"marker\":{},\"line\":{}}];\n",
       "        var layout = {\"width\":0,\"height\":400,\"template\":{\"layout\":{\"margin\":{\"l\":30.0,\"r\":30.0,\"t\":30.0,\"b\":30.0},\"autosize\":true},\"data\":{}}};\n",
       "        var config = {\"responsive\":true};\n",
       "        Plotly.newPlot('5d2dd2b9-177b-4f94-b81d-9aceb5716cd8', data, layout, config);\n",
       "    });\n",
       "};\n",
       "if ((typeof(requirejs) !==  typeof(Function)) || (typeof(requirejs.config) !== typeof(Function))) {\n",
       "    var script = document.createElement(\"script\");\n",
       "    script.setAttribute(\"charset\", \"utf-8\");\n",
       "    script.setAttribute(\"src\", \"https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.6/require.min.js\");\n",
       "    script.onload = function(){\n",
       "        renderPlotly_5d2dd2b9177b4f94b81d9aceb5716cd8();\n",
       "    };\n",
       "    document.getElementsByTagName(\"head\")[0].appendChild(script);\n",
       "}\n",
       "else {\n",
       "    renderPlotly_5d2dd2b9177b4f94b81d9aceb5716cd8();\n",
       "}\n",
       "</script></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// define our data source\n",
    "[<Literal>]\n",
    "let uri = \"http://query1.finance.yahoo.com/v7/finance/download/MSFT?period1=1678116713&period2=1709739113&interval=1d&events=history&includeAdjustedClose=true\"\n",
    "\n",
    "// create a type using it\n",
    "// (normally, we'd pass a smaller and local file with the same structure here, but passing the same `uri` is fine for example / notebooks)\n",
    "type Stocks = CsvProvider<uri>\n",
    "\n",
    "// get a sample of the data from the new type using the default data source\n",
    "let msft = Stocks.GetSample()\n",
    "\n",
    "// plot the high vs low daily difference over time\n",
    "Chart.Line([ for row in msft.Rows -> row.Date, row.High - row.Low ])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b57f81c",
   "metadata": {},
   "source": [
    "Working with type providers can sometimes be less convenient than dynamically typed data access libraries like `pandas`'s `DataFrame` when your data isn't well structured.\n",
    "\n",
    "For example, if you had data with similar structure as above (`Date`, `Open`, `Adj Close`, etc., columns) but for multiple companies all in one CSV file, they might be addressed with the name of the company first, then the column name, such as `MSFT_Date`, for example.\n",
    "\n",
    "You could access this data in an unsafe way using programmatic access, such as with f-strings in Python (`frame[f\"{ticker}_{column_name}\"]`), but F# type providers would have no knowledge of the implicit structure via column naming because CSV does not allow for multi-level indexing unlike other data types like JSON. In fact, iterating over all or a subset of columns from a `CsvProvider` type requires a hack, and you'd be better off importing into a semi-strongly-typed `DataFrame` using a package called [Deedle](https://fslab.org/Deedle) than using type providers. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "722aa15f",
   "metadata": {},
   "source": [
    "However, when you need to access a few named columns of homogenous types, it's actually not too difficult to work with the data provided from type providers as pure collections and not use a data frame at all:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "293fd974",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "__MSFT Stock Highs and Lows__"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/csv": [
       "Date,High,Low\r\n",
       "2023-03-06T00:00:00.0000000-06:00,260.119995,255.979996\r\n",
       "2023-03-07T00:00:00.0000000-06:00,257.690002,253.389999\r\n",
       "2023-03-08T00:00:00.0000000-06:00,254.539993,250.809998\r\n",
       "2023-03-09T00:00:00.0000000-06:00,259.559998,251.580002\r\n",
       "2023-03-10T00:00:00.0000000-06:00,252.789993,247.600006\r\n",
       "2023-03-13T00:00:00.0000000-05:00,257.910004,245.729996\r\n",
       "2023-03-14T00:00:00.0000000-05:00,261.070007,255.860001\r\n"
      ],
      "text/html": [
       "<table><thead><tr><td><span>Date</span></td><td><span>High</span></td><td><span>Low</span></td></tr></thead><tbody><tr><td><span>2023-03-06 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>260.119995</pre></div></td><td><div class=\"dni-plaintext\"><pre>255.979996</pre></div></td></tr><tr><td><span>2023-03-07 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>257.690002</pre></div></td><td><div class=\"dni-plaintext\"><pre>253.389999</pre></div></td></tr><tr><td><span>2023-03-08 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>254.539993</pre></div></td><td><div class=\"dni-plaintext\"><pre>250.809998</pre></div></td></tr><tr><td><span>2023-03-09 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>259.559998</pre></div></td><td><div class=\"dni-plaintext\"><pre>251.580002</pre></div></td></tr><tr><td><span>2023-03-10 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>252.789993</pre></div></td><td><div class=\"dni-plaintext\"><pre>247.600006</pre></div></td></tr><tr><td><span>2023-03-13 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>257.910004</pre></div></td><td><div class=\"dni-plaintext\"><pre>245.729996</pre></div></td></tr><tr><td><span>2023-03-14 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>261.070007</pre></div></td><td><div class=\"dni-plaintext\"><pre>255.860001</pre></div></td></tr></tbody></table><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "__MSFT Stock Highs and Lows - Resample and Average__"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/csv": [
       "Date,High,Low\r\n",
       "2023-03-06T00:00:00.0000000-06:00,256.9399962,251.8720002\r\n",
       "2023-03-13T00:00:00.0000000-05:00,269.0700014,260.0799988\r\n",
       "2023-03-20T00:00:00.0000000-05:00,279.0420046,272.4059998\r\n"
      ],
      "text/html": [
       "<table><thead><tr><td><span>Date</span></td><td><span>High</span></td><td><span>Low</span></td></tr></thead><tbody><tr><td><span>2023-03-06 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>256.9399962</pre></div></td><td><div class=\"dni-plaintext\"><pre>251.8720002</pre></div></td></tr><tr><td><span>2023-03-13 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>269.0700014</pre></div></td><td><div class=\"dni-plaintext\"><pre>260.0799988</pre></div></td></tr><tr><td><span>2023-03-20 00:00:00Z</span></td><td><div class=\"dni-plaintext\"><pre>279.0420046</pre></div></td><td><div class=\"dni-plaintext\"><pre>272.4059998</pre></div></td></tr></tbody></table><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let resample (interval : TimeSpan) (observations : (DateTime * decimal array) seq) =\n",
    "    observations\n",
    "        |> Seq.groupBy (fun (dt, _) -> dt.Ticks / interval.Ticks)\n",
    "        |> Seq.map (fun (_, group) -> \n",
    "            group |> Seq.map fst |> Seq.head,\n",
    "            group |> Seq.map snd |> Seq.transpose |> Seq.map Seq.average |> Array.ofSeq)\n",
    "\n",
    "let print observations =\n",
    "    observations\n",
    "    |> Seq.map (fun (date, (cols : 'a array)) -> {| Date = date; Low = cols[0]; High = cols[1] |})\n",
    "    |> _.DisplayTable()\n",
    "\n",
    "\"__MSFT Stock Highs and Lows__\" |> _.DisplayAs(\"text/markdown\")\n",
    "msft.Rows\n",
    "    |> Seq.map (fun row -> row.Date, [| row.Low; row.High |])\n",
    "    |> Seq.take 7\n",
    "    |> print\n",
    "\n",
    "\"__MSFT Stock Highs and Lows - Resample and Average__\" |> _.DisplayAs(\"text/markdown\")\n",
    "msft.Rows\n",
    "    |> Seq.map (fun row -> row.Date, [| row.Low; row.High |])\n",
    "    |> resample (TimeSpan.FromDays 7)\n",
    "    |> Seq.take 3\n",
    "    |> print"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c7a84e3",
   "metadata": {},
   "source": [
    "If you do need access to a data frame, it's pretty trivial to import data into a `DataFrame` using Deedle and perform operations on it. You won't get the helpful IntelliSense hints informing you of valid navigations, and you'll get most type errors at runtime instead of compile time, but the errors should be clearer than Python in most cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "c5479b71",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div></div><div></div><div><strong>Installed Packages</strong><ul><li><span>Deedle, 3.0.0</span></li></ul></div></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#r \"nuget: Deedle\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "713e5fe8",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "open System.Net\n",
    "open System.Net.Http\n",
    "open Deedle\n",
    "\n",
    "[<Literal>]\n",
    "let url = \"http://query1.finance.yahoo.com/v7/finance/download/MSFT?period1=1678116713&period2=1709739113&interval=1d&events=history&includeAdjustedClose=true\"\n",
    "let frame = \n",
    "    Frame.ReadCsv((new HttpClient()).GetStreamAsync(url).Result)\n",
    "    |> Frame.indexRowsDate \"Date\"\n",
    "\n",
    "frame.Print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf3f25e2",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3/6/2023 12:00:00 AM   -> 251.8720002        \r\n",
      "3/13/2023 12:00:00 AM  -> 260.0799988        \r\n",
      "3/20/2023 12:00:00 AM  -> 272.40599979999996 \r\n",
      "3/27/2023 12:00:00 AM  -> 278.0919984        \r\n",
      "4/3/2023 12:00:00 AM   -> 283.64250925       \r\n",
      "4/10/2023 12:00:00 AM  -> 283.0340024        \r\n",
      "4/17/2023 12:00:00 AM  -> 285.17000160000003 \r\n",
      "4/24/2023 12:00:00 AM  -> 289.076001         \r\n",
      "5/1/2023 12:00:00 AM   -> 304.1639953999999  \r\n",
      "5/8/2023 12:00:00 AM   -> 306.58600459999997 \r\n",
      "5/15/2023 12:00:00 AM  -> 311.6499938        \r\n",
      "5/22/2023 12:00:00 AM  -> 317.95             \r\n",
      "5/29/2023 12:00:00 AM  -> 328.77999124999997 \r\n",
      "6/5/2023 12:00:00 AM   -> 327.41800539999997 \r\n",
      "6/12/2023 12:00:00 AM  -> 333.5020082        \r\n",
      "...                    -> ...                \r\n",
      "11/27/2023 12:00:00 AM -> 375.7160034        \r\n",
      "12/4/2023 12:00:00 AM  -> 366.2200012        \r\n",
      "12/11/2023 12:00:00 AM -> 367.547998         \r\n",
      "12/18/2023 12:00:00 AM -> 370.3599976        \r\n",
      "12/25/2023 12:00:00 AM -> 373.48750325000003 \r\n",
      "1/1/2024 12:00:00 AM   -> 367.237503         \r\n",
      "1/8/2024 12:00:00 AM   -> 376.31000359999996 \r\n",
      "1/15/2024 12:00:00 AM  -> 389.012497         \r\n",
      "1/22/2024 12:00:00 AM  -> 398.5859986        \r\n",
      "1/29/2024 12:00:00 AM  -> 402.6699952        \r\n",
      "2/5/2024 12:00:00 AM   -> 408.3839966        \r\n",
      "2/12/2024 12:00:00 AM  -> 406.0880066        \r\n",
      "2/19/2024 12:00:00 AM  -> 403.19250475       \r\n",
      "2/26/2024 12:00:00 AM  -> 406.6660032        \r\n",
      "3/4/2024 12:00:00 AM   -> 403.78334566666666 \r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "let df =\n",
    "    frame?Low\n",
    "    |> Series.sampleTime (TimeSpan.FromDays 7) Direction.Forward\n",
    "    |> Series.mapValues (fun v -> Stats.mean v)\n",
    "df.Print()"
   ]
  }
 ],
 "metadata": {
  "dotnet_interactive": {
   "defaultKernelName": "fsharp",
   "items": [
    {
     "name": "fsharp"
    }
   ]
  },
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "file_extension": ".fs",
   "mimetype": "text/x-fsharp",
   "name": "polyglot-notebook",
   "pygments_lexer": "fsharp",
   "version": "6.0"
  },
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "csharp",
    "items": [
     {
      "aliases": [],
      "name": "csharp"
     },
     {
      "aliases": [],
      "name": "fsharp"
     },
     {
      "aliases": [],
      "languageName": "python",
      "name": "pythonkernel"
     }
    ]
   }
  },
  "title": "F# Guide - Up and Running"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}