fs-http.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accelerate Your Development with FsHttp and FSharp.Data\n",
    "\n",
    "> Ditch cURL and Postman for readable HTTP queries and a parser that understands your data before you write a line of code\n",
    "<div>\n",
    "<style>\n",
    "@scope {\n",
    "    p {\n",
    "        margin: 0;\n",
    "    }\n",
    "}\n",
    "</style>\n",
    "<div style=\"display: flex; justify-content: space-between; align-items: center;\">\n",
    "<time datetime=\"2024-09-03\">September 3, 2024</time>\n",
    "<div style=\"display: flex; flex-flow: wrap; align-items: center; flex: 1; margin-bottom: 4px; justify-content: end; margin-left: 1em; column-gap: 0.5em;\">\n",
    "<div style=\"margin-bottom: 1px;\">\n",
    "\n",
    "[![Open in VS Code](media/open-in-vscode.svg)](vscode://vscode.git/clone?url=https://github.com/johnW-ret/blog)\n",
    "</div>\n",
    "<div>\n",
    "\n",
    "[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://github.com/codespaces/new?template_repository=johnW-ret/blog)\n",
    "</div>\n",
    "</div>\n",
    "</div>\n",
    "</div>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So you have to hit a new JSON API. Is there an SDK library? Nope.\n",
    "\n",
    "Forgot what flag you need for cURL? Time to use Postman. Postman asking you to sign in? Hmm... maybe you want a notebook experience? `pip install requests` but your Python installation is broken again....\n",
    "\n",
    "You think to yourself,\n",
    "\n",
    "> _there has to be a better way!_\n",
    "\n",
    "Well, fortunately, there is. And today I'm going to help you set it up in a matter of minutes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation 🧑‍💻\n",
    "### _.NET runs on Mac?!_\n",
    "\n",
    "First, you need to install [dot.net](https://dot.net).\n",
    "\n",
    "Now, I maybe can guess what you might be thinking.\n",
    "> _Another SDK? Just for glorified cURL?_\n",
    "\n",
    "Maybe the best part of .NET is the developer experience. It's on your favorite package manager, there aren't any \".NET version managers\" - you just install the version you want and it works, and you install _tools_ globally, not _packages_, so you couldn't even break your installation just by installing packages if you tried."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Polyglot Notebooks\n",
    "The .NET SDK already comes with all the F# tools we need to run these commands in the terminal with `fsi`, but this experience works much better with Polyglot Notebooks over VSCode with `code --install-extension ms-dotnettools.dotnet-interactive-vscode`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Syntax Sugar 🍬\n",
    "The first package I'd like to show is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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>FsHttp, 14.5.1</span></li></ul></div></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#r \"nuget: FsHttp\"\n",
    "\n",
    "open FsHttp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Postman is useful because we - as humans - don't always remember the exact names of all the headers of the HTTP specification. But we kinda do at least know what a HTTP request is supposed to look like.\n",
    "\n",
    "FsHttp uses an F# feature called computation expressions (see builder pattern, monad) to wrap `System.Net.Http` so _it actually looks like an HTTP request_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\r\n",
       "  \"batchcomplete\": \"\",\r\n",
       "  \"warnings\": {\r\n",
       "    \"main\": {\r\n",
       "      \"*\": \"Subscribe to the mediawiki-api-announce mailing list at \\u003Chttps://lists.wikimedia.org/postorius/lists/mediawiki-api-announce.lists.wikimedia.org/\\u003E for notice of API deprecations and breaking changes. Use [[Special:ApiFeatureUsage]] to see usage of deprecated features by your application.\"\r\n",
       "    },\r\n",
       "    \"revisions\": {\r\n",
       "      \"*\": \"Because \\u0022rvslots\\u0022 was not specified, a legacy format has been used for the output. This format is deprecated, and in the future the new format will always be used.\"\r\n",
       "    }\r\n",
       "  },\r\n",
       "  \"query\": {\r\n",
       "    \"pages\": {\r\n",
       "      \"14156\": {\r\n",
       "        \"pageid\": 14156,\r\n",
       "        \"ns\": 0,\r\n",
       "        \"title\": \"\\u5B9D\",\r\n",
       "        \"revisions\": [\r\n",
       "          {\r\n",
       "            \"contentformat\": \"text/x-wiki\",\r\n",
       "            \"contentmodel\": \"wikitext\",\r\n",
       "            \"*\": \"==Japanese==\\n{{ja-kanji forms|\\u5B9D|\\u5BF6}}\\n\\n===Kanji===\\n{{ja-kanji|grade=6|rs=\\u5B8005|kyu=\\u5BF6}}\\n\\n# [[precious]] [[objects]]\\n# [[worldly]] [[goods]]\\n# [[valuable]] [[possessions]]\\n\\n====Readings====\\n{{ja-readings\\n|goon=\\u307B\\u3046\\n|kanon=\\u307B\\u3046\\n|kanyoon=\\u307B\\n|kun=\\u305F\\u304B\\u3089-\\n}}\\n\\n===Etymology===\\n{{ja-kanjitab|\\u305F\\u304B\\u3089|yomi=k|alt=\\u8CA1,\\u8CA8}}\\n\\nFrom {{inherited|ja|ojp|-|sort=\\u305F\\u304B\\u3089}}. First cited to the \\u0027\\u0027{{w|Man\\u0027y\\u014Dsh\\u016B}}\\u0027\\u0027 of 759 {{CE}}.\\u003Cref\\u003E{{R:Nihon Kokugo Daijiten 2|\\u5B9D\\u30FB\\u8CA1\\u30FB\\u8CA8}}\\u003C/ref\\u003E From {{inh|ja|jpx-pro|*takara}}.\\n\\nSamuel Martin analyzes this as a compound of {{m|ja|\\u9AD8|tr=taka-|t=high}} \\u002B {{m|ja|\\u7B49|tr=-ra|pos=pluralizing suffix}}.\\u003Cref\\u003E{{R:ja:Martin 1987}}\\u003C/ref\\u003E  However, this is semantically problematic, as such a compound would ordinarily refer to \\u0022the [[heights]]\\u0022 as a location, and there is no clear means of deriving the sense of \\u0022[[treasure]]\\u0022 from the proposed component parts.\\n\\nSome sources derive this as a compound of {{com|ja|\\u7530|tr1=ta|t1=paddy field|\\u304B\\u3089|tr2=kara|t2=from|lit=from the paddy fields}}, from the way people value thriving paddy fields as a unique kind of treasure.\\u003Cref\\u003E[https://www.takarashuzo.co.jp/takarahatakara/ \\u5B9D\\u306F\\u7530\\u304B\\u3089\\uFF5E\\u79C1\\u305F\\u3061\\u306E\\u539F\\u70B9\\uFF5E | \\u5B9D\\u9152\\u9020\\u682A\\u5F0F\\u4F1A\\u793E] - Treasure is from the rice fields -Our Beginning- | Takara Shuzo (In Japanese)\\u003C/ref\\u003E  However, the sense of \\u0022from\\u0022 for {{ja-r|\\u304B\\u3089}} does not appear until roughly the {{w|Heian period}},\\u003Cref\\u003E{{R:Nihon Kokugo Daijiten 2|\\u304B\\u3089}}\\u003C/ref\\u003E more recent than the first appearance of \\u0027\\u0027takara\\u0027\\u0027, making this a [[folk etymology]].\\n\\n===Pronunciation===\\n{{ja-pron|\\u305F\\u304B\\u3089|acc=3|acc_ref=DJR,SMK5,NHK}}\\n\\n===Noun===\\n{{ja-noun|\\u305F\\u304B\\u3089}}\\n\\n# {{defdate|from 759}} [[treasure]]\\n\\n===References===\\n\\u003Creferences/\\u003E\"\r\n",
       "          }\r\n",
       "        ]\r\n",
       "      }\r\n",
       "    }\r\n",
       "  }\r\n",
       "}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "http {\n",
    "    GET \"https://en.wiktionary.org/w/api.php?action=query&titles=%E5%AE%9D&prop=revisions&rvprop=content&rvsection=9&format=json\"\n",
    "}\n",
    "|> Request.send\n",
    "|> Response.toFormattedText"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Postman's UI makes it ease to identify the headers you need, but Postman is less trivial to edit and document with (see Postman collections).\n",
    "\n",
    "FsHttp requests stored in fsi/ipynb files are just that - files, so they're dead simple to edit and document, but IntelliSense makes it trivial to write the exact request you want. Fun!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![bang](media/fshttp-intellisense0.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[HTTP files](https://learn.microsoft.com/en-us/aspnet/core/test/http-files) can be a great alternative to Postman. Simply put - HTTP files store HTTP requests in text form, and your editor tooling can help you fill out the appropriate request and execute it.\n",
    "\n",
    "![http file UI in Visual Studio](media/http-file-use0.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even use HTTP files in the form of HttpRepl blocks in a polyglot notebook!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "dotnet_interactive": {
     "language": "powershell"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [],
   "source": [
    "Start-ThreadJob -ScriptBlock {\n",
    "    # Define the URL and path\n",
    "    $url = \"http://localhost:8080/foo\"\n",
    "\n",
    "    # Define the content to write\n",
    "    $content = \"So a foo walks into a bar...\"\n",
    "\n",
    "    # Create an HttpListener\n",
    "    $listener = [System.Net.HttpListener]::new()\n",
    "    $listener.Prefixes.Add(\"http://localhost:8080/\")\n",
    "\n",
    "    # Start the listener\n",
    "    $listener.Start()\n",
    "    Write-Host \"Listening on http://localhost:8080/\"\n",
    "\n",
    "    $context = $listener.GetContext()\n",
    "    $response = $context.Response\n",
    "\n",
    "    $buffer = [System.Text.Encoding]::UTF8.GetBytes($content)\n",
    "    $response.ContentLength64 = $buffer.Length\n",
    "    $response.OutputStream.Write($buffer, 0, $buffer.Length)\n",
    "    $response.OutputStream.Close()\n",
    "}\n",
    "| Out-Null"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "dotnet_interactive": {
     "language": "http"
    },
    "polyglot_notebook": {
     "kernelName": "http"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"http-response-message-container\"><style type=\"text/css\">\r\n",
       "            .http-response-message-container {\r\n",
       "                display: flex;\r\n",
       "                flex-wrap: wrap;\r\n",
       "            }\r\n",
       "\r\n",
       "            .http-response-message-container > div {\r\n",
       "                margin: .5em;\r\n",
       "                padding: 1em;\r\n",
       "                border: 1px solid;\r\n",
       "            }\r\n",
       "\r\n",
       "            .http-response-message-container > div > h2 {\r\n",
       "                margin-top: 0;\r\n",
       "            }\r\n",
       "\r\n",
       "            .http-response-message-container > div > h3 {\r\n",
       "                margin-bottom: 0;\r\n",
       "            }\r\n",
       "\r\n",
       "            .http-response-message-container summary {\r\n",
       "                margin: 1em 0;\r\n",
       "                font-size: 1.17em;\r\n",
       "                font-weight: 700;\r\n",
       "            }\r\n",
       "\r\n",
       "            @keyframes blink {\r\n",
       "                0% {\r\n",
       "                  opacity: .2;\r\n",
       "                }\r\n",
       "                20% {\r\n",
       "                  opacity: 1;\r\n",
       "                }\r\n",
       "                100% {\r\n",
       "                  opacity: .2;\r\n",
       "                }\r\n",
       "            }\r\n",
       "\r\n",
       "            .ellipsis span {\r\n",
       "                animation-name: blink;\r\n",
       "                animation-duration: 1.4s;\r\n",
       "                animation-iteration-count: infinite;\r\n",
       "                animation-fill-mode: both;\r\n",
       "            }\r\n",
       "\r\n",
       "            .ellipsis span:nth-child(2) {\r\n",
       "                animation-delay: .2s;\r\n",
       "            }\r\n",
       "\r\n",
       "            .ellipsis span:nth-child(3) {\r\n",
       "                animation-delay: .4s;\r\n",
       "            }</style><div><h2>Request</h2><hr></hr><h3>GET <a href=\"http://localhost:8080/\">http://localhost:8080/</a> HTTP/1.1</h3><details><summary>Headers</summary><table><thead><tr><th>Name</th><th>Value</th></tr></thead><tbody><tr><td>traceparent</td><td>00-d014d1bb9493ce82c59e4937d559bf7d-f62abc9ef7a72494-00</td></tr></tbody></table></details><details><summary>Body (0 bytes)</summary><pre></pre></details></div><div><h2>Response</h2><hr></hr><h3>HTTP/1.1 200 OK (590.35 ms)</h3><details open=\"True\"><summary>Headers</summary><table><thead><tr><th>Name</th><th>Value</th></tr></thead><tbody><tr><td>Server</td><td>Microsoft-HTTPAPI/2.0</td></tr><tr><td>Date</td><td>Wed, 04 Sep 2024 02:37:34 GMT</td></tr><tr><td>Content-Length</td><td>28</td></tr></tbody></table></details><details open=\"True\"><summary>Body (28 bytes)</summary>So a foo walks into a bar...</details></div></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "GET http://localhost:8080"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "dotnet_interactive": {
     "language": "pwsh"
    },
    "polyglot_notebook": {
     "kernelName": "pwsh"
    }
   },
   "outputs": [],
   "source": [
    "Stop-Job -Id 1\n",
    "Remove-Job -Id 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we haven't found a strong reason to use FsHttp over HTTP files, but there's one big advantage FsHttp has over HTTP files: __programmability__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data as First-Class Citizens 🗳️\n",
    "\n",
    "If you're familiar with Python or JavaScript, you might be used to dot-navigating your way through API responses but having to do data validation manually. If you've used C#, you're probably used to getting a lot of data validation for cheap with `JsonDeserialize`, while still having to define your schema up front with `record`s and `class`es.\n",
    "\n",
    "With F# type providers, you can actually get the benefit of both of these with neither of the costs. Let me show you what I mean:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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"
    }
   ],
   "source": [
    "#r \"nuget: FSharp.Data\"\n",
    "open FSharp.Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>[ dotnet/fsharp, fable-compiler/Fable, fsharp/fsharp, giraffe-fsharp/Giraffe, fsprojects/Paket ]</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": [
    "type GitHubRepositories = JsonProvider<\n",
    "\"\"\"\n",
    "{\n",
    "  \"items\": [\n",
    "    {\n",
    "      \"id\": 29048891,\n",
    "      \"name\": \"fsharp\",\n",
    "      \"full_name\": \"dotnet/fsharp\"\n",
    "    }\n",
    "  ]\n",
    "}\n",
    "\"\"\">\n",
    "\n",
    "GitHubRepositories.Load(\"https://api.github.com/search/repositories?q=language:fsharp&per_page=5\")\n",
    "  .Items\n",
    "  |> Array.map (_.FullName)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, we gave `JsonProvider` an inline sample of our schema. This sample got ingested by the build process and was used to generate the rest of the `GitHubRepositories` type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passing in hard-coded or file referenced samples like this is recommended in real applications since the data becomes part of the build process. However, for just experimenting in an interactive session, it's perfectly fine to directly pass an API endpoint to `JsonProvider`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>index</i></th><th>value</th></tr></thead><tbody><tr><td>0</td><td><details class=\"dni-treeview\"><summary><span class=\"dni-code-hint\"><code>(dotnet/fsharp, 3862)</code></span></summary><div><table><thead><tr></tr></thead><tbody><tr><td>Item1</td><td><div class=\"dni-plaintext\"><pre>dotnet/fsharp</pre></div></td></tr><tr><td>Item2</td><td><div class=\"dni-plaintext\"><pre>3862</pre></div></td></tr></tbody></table></div></details></td></tr><tr><td>1</td><td><details class=\"dni-treeview\"><summary><span class=\"dni-code-hint\"><code>(fable-compiler/Fable, 2887)</code></span></summary><div><table><thead><tr></tr></thead><tbody><tr><td>Item1</td><td><div class=\"dni-plaintext\"><pre>fable-compiler/Fable</pre></div></td></tr><tr><td>Item2</td><td><div class=\"dni-plaintext\"><pre>2887</pre></div></td></tr></tbody></table></div></details></td></tr><tr><td>2</td><td><details class=\"dni-treeview\"><summary><span class=\"dni-code-hint\"><code>(fsharp/fsharp, 2172)</code></span></summary><div><table><thead><tr></tr></thead><tbody><tr><td>Item1</td><td><div class=\"dni-plaintext\"><pre>fsharp/fsharp</pre></div></td></tr><tr><td>Item2</td><td><div class=\"dni-plaintext\"><pre>2172</pre></div></td></tr></tbody></table></div></details></td></tr><tr><td>3</td><td><details class=\"dni-treeview\"><summary><span class=\"dni-code-hint\"><code>(giraffe-fsharp/Giraffe, 2106)</code></span></summary><div><table><thead><tr></tr></thead><tbody><tr><td>Item1</td><td><div class=\"dni-plaintext\"><pre>giraffe-fsharp/Giraffe</pre></div></td></tr><tr><td>Item2</td><td><div class=\"dni-plaintext\"><pre>2106</pre></div></td></tr></tbody></table></div></details></td></tr><tr><td>4</td><td><details class=\"dni-treeview\"><summary><span class=\"dni-code-hint\"><code>(fsprojects/Paket, 2014)</code></span></summary><div><table><thead><tr></tr></thead><tbody><tr><td>Item1</td><td><div class=\"dni-plaintext\"><pre>fsprojects/Paket</pre></div></td></tr><tr><td>Item2</td><td><div class=\"dni-plaintext\"><pre>2014</pre></div></td></tr></tbody></table></div></details></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": [
    "type GitHubRepositories = JsonProvider<\"https://api.github.com/search/repositories?q=language:fsharp&per_page=5\">\n",
    "\n",
    "GitHubRepositories.GetSample()\n",
    "    .Items\n",
    "    |> Array.map (fun x -> x.FullName, x.StargazersCount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because FsHttp is a wrapper for building *requests* and FSharp.Data is a library for intepreting (well, data generally, but in our case) *responses*, and because .NET has an awesome \"work together\" culture instead of \"rebuild a worse version yourself 'from ground up'\" culture, these two libraries work together rather flawlessly ✨:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>[ -う, い.かす, い.きる, い.ける, う.まれ, う.まれる, う.む, うま.れる, うまれ, お.う, き, な.す, な.る, なま, なま-, は.える, は.やす, む.す, ショウ, セイ ]</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": [
    "type Kanji = JsonProvider<\"https://kanjiapi.dev/v1/kanji/力\">\n",
    "\n",
    "let stream =\n",
    "    http {\n",
    "        GET \"https://kanjiapi.dev/v1/kanji/生\"\n",
    "    }\n",
    "    |> Request.send\n",
    "    |> Response.toStream\n",
    "\n",
    "let 生 = Kanji.Load(stream)\n",
    "\n",
    "Array.concat (seq { 生.KunReadings; 生.OnReadings; })"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next Steps 🤔\n",
    "Don't wait! If a lot of things in this blog post seemed unfamiliar, you will assume they're hard and have already created a mental blockade. You will need an HTTP client later, but the energy to set up FsHttp will seem greater than dealing with the overhead of your Least Common Denominator tool, but over time that overhead will pile up and contribute to developer burn out.\n",
    "\n",
    "Refresh your toolkit today! Start installing [dot.net](https://dot.net), take a break from the computer screen and stretch those legs, then [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://github.com/codespaces/new?template_repository=johnW-ret/blog) in the browser or [![Open in VS Code](media/open-in-vscode.svg)](vscode://vscode.git/clone?url=https://github.com/johnW-ret/blog)!\n",
    "\n",
    "Happy coding!\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "csharp",
    "items": [
     {
      "aliases": [],
      "name": "csharp"
     },
     {
      "aliases": [],
      "languageName": "fsharp",
      "name": "fsharp"
     }
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}