Tacit Techniques.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a5d9afb1",
   "metadata": {},
   "source": [
    "# Tacit Techniques\n",
    "\n",
    "Tacit, also known as point-free, programming is a key feature of Dyalog APL, but is not unique to it. Amongst others, J and Haskell also support this programming style. It has a somewhat undeserved reputation of being hard to learn and read, and the purpose of this tutorial is to help dispel this notion. Tacit is for everyone. \n",
    "\n",
    "## Other resources\n",
    "\n",
    "- Tacit tutorials on [APL Wiki](https://apl.wiki/tacit#Tutorials)\n",
    "- Adám Brudzewsky's [tacit cultivation](https://xpqz.github.io/cultivations/Trains)\n",
    "- Rich Park's video [Train Spotting](https://youtu.be/Enlh5qwwDuY)\n",
    "- Stefan Kruger's chapter on [Train Spotting](https://xpqz.github.io/learnapl/tacit.html) in Learn APL\n",
    "\n",
    "## Audience\n",
    "\n",
    "This is an intermediate level tutorial. To make the most of it, you already know a bit of Dyalog APL. You know how to write dfns and tradfns, how to operate the IDE (or Ride), and how to execute APL expressons in the session. This tutorial will help you take the next steps in terms of tacit programming.\n",
    "\n",
    "\n",
    "## Essence of Tacit Programming\n",
    "\n",
    "Explicit code references function arguments explicitly. For example, here's an expression that calculates the difference between the max and min values of a vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a71a3714",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">8\n",
       "</pre>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(⌈/N) - ⌊/N ← 3 1 4 1 5 9 2 6 5  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bed6334",
   "metadata": {},
   "source": [
    "We're naming the input vector `N` and referencing it explicitly later. Similarly, we name the arguments of a tradfn explicitly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ff62d5d8",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [],
   "source": [
    "∇ R ← Range Y\n",
    "  R ← (⌈/Y) - ⌊/Y\n",
    "∇"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "31333faf",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">8\n",
       "</pre>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Range 3 1 4 1 5 9 2 6 5  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1d04aa5",
   "metadata": {},
   "source": [
    "In dfns, the left and right arguments already have the names `⍺` and `⍵` respectively, and we can reference those explicitly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d2081cc0",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">8\n",
       "</pre>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{(⌈/⍵) - ⌊/⍵} 3 1 4 1 5 9 2 6 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af2a2400",
   "metadata": {},
   "source": [
    "In contrast, in tacit code, arguments are *implied*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "39afe3a0",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">8\n",
       "</pre>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(⌈/ - ⌊/) 3 1 4 1 5 9 2 6 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea5adc4e",
   "metadata": {},
   "source": [
    "Note how this actually reads nicely in English: the max `⌈/` minus the min `⌊/`.\n",
    "\n",
    "Here's the thing -- even if you're new to tacit, you have most likely been using it unknowingly already. For example, all the following expressions are examples of tacit programming you may alreay be using:\n",
    "\n",
    "- `f/`\n",
    "- `f¨`\n",
    "- `∘.g`\n",
    "- `f\\`\n",
    "- `A∘g`\n",
    "- `f⌸`\n",
    "- `f⍠B`\n",
    "\n",
    "In other words, operator application is a form of tacit programming."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf4c0803",
   "metadata": {},
   "source": [
    "## Advantages of Tacit Programming\n",
    "\n",
    "What are the advantages of tacit progamming? Here are some:\n",
    "\n",
    "- Memorable phrases (like `≠⊆⊢` and `+⌿÷≢`)\n",
    "- Adjacency (like `×-` and `∨/⍷`)\n",
    "- Brevity (like `F⍥⎕C`)\n",
    "- DRY (Don’t Repeat Yourself; like `≡⍥⍴`)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "982fbc08",
   "metadata": {},
   "source": [
    "## Function Composition\n",
    "\n",
    "One way to think about tacit programming is known as [function composition](https://help.dyalog.com/latest/index.htm#Language/Primitive%20Operators/Operator%20Syntax.htm#Function_Composition). Dyalog has several ways in which to compose functions into new functions, including:\n",
    "\n",
    "- [Over](https://help.dyalog.com/latest/index.htm#Language/Primitive%20Operators/Over.htm) `f⍥g`\n",
    "- [Beside](https://help.dyalog.com/latest/index.htm#Language/Primitive%20Operators/Beside.htm) `f∘g`\n",
    "- [Atop](https://help.dyalog.com/latest/index.htm#Language/Primitive%20Operators/Atop.htm) `f⍤g`\n",
    "- [Commute](https://help.dyalog.com/latest/index.htm#Language/Primitive%20Operators/Commute.htm) `f⍨`\n",
    "- [Fork](https://help.dyalog.com/latest/index.htm#Language/Introduction/Trains.htm) `fgh`\n",
    "\n",
    "As it turns out, function composition is \"just\" a matter of plumbing -- let's work through these compositions in turn to discover how they work."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fb923fa",
   "metadata": {},
   "source": [
    "### Over\n",
    "\n",
    "\n",
    "<div style=\"float: right; margin-left: 10px;\">\n",
    "    <img src=\"images/over.png\" style=\"width:120px; height:auto; border: 1px solid #000000;\">\n",
    "</div>\n",
    "\n",
    "\n",
    "The shape of an outer product `⍺ ∘.f ⍵` is\n",
    "\n",
    "```apl\n",
    "(⍴⍺) , (⍴⍵)\n",
    "```\n",
    "\n",
    "We can look at this as the the application of the *catenate* (`,`) function after pre-processing both the right and left arguments with the *shape* (`⍴`) function.\n",
    "\n",
    "Using the [Over](https://help.dyalog.com/latest/index.htm#Language/Primitive%20Operators/Over.htm) operator, `⍥`, we can write this as\n",
    "\n",
    "```apl\n",
    "⍺ ,⍥⍴ ⍵\n",
    "```\n",
    "\n",
    "\n",
    "We can model this as a diagram. In this case, the `f` function is *catenate*, and `g` is *shape*. We read `,⍥⍴` as \"catenate over shape\", but we think \"catenate the arguments, pre-processed by shape\". \n",
    "\n",
    "This is a common pattern in APL code. Perhaps you want to see if two vectors have the same tally? Think \"equal over tally\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fe080b6a",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1\n",
       "</pre>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ← 1 2 3 4 5 6 7 8 9 10 11\n",
    "b ← 'hello world'\n",
    "a =⍥≢ b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ccddce9",
   "metadata": {},
   "source": [
    "### Beside\n",
    "\n",
    "<div style=\"float: right; margin-left: 10px;\">\n",
    "    <img src=\"images/beside.png\" style=\"width:120px; height:auto; border: 1px solid #000000;\">\n",
    "</div>\n",
    "\n",
    "Location of the `⍺`<sup>th</sup> 1 in each element of `⍵` is\n",
    "\n",
    "```apl\n",
    "⍺ ⊃¨ ⍸¨ ⍵\n",
    "```\n",
    "Using the [Beside](https://help.dyalog.com/latest/index.htm#Language/Primitive%20Operators/Beside.htm) (`∘`) operator, we can write this more succinctly as\n",
    "\n",
    "```apl\n",
    "⍺ ⊃∘⍸¨ ⍵\n",
    "```\n",
    "In an expression `⍺ f∘g ⍵`, we can think of *beside* as pre-processing the *right* argument with the monadic `g` function, and then applying the dyadic function `f`. Read `⊃∘⍸` as \"pick beside where\".\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d62dc9c4",
   "metadata": {},
   "source": [
    "### Atop\n",
    "\n",
    "<div style=\"float: right; margin-left: 10px;\">\n",
    "    <img src=\"images/atop.png\" style=\"width:120px; height:auto; border: 1px solid #000000;\">\n",
    "</div>\n",
    "\n",
    "Any-presence of `⍺` in `⍵` is \n",
    "```apl\n",
    "∨/ ⍺ ⍷ ⍵\n",
    "```\n",
    "We can write this as\n",
    "```apl\n",
    "⍺ ∨/⍤⍷ ⍵\n",
    "```\n",
    "using the [Atop](https://help.dyalog.com/latest/index.htm#Language/Primitive%20Operators/Atop.htm) operator, which reads as \"or-reduce atop find\". *Atop* means \"post-process the result\", which in our case is \"post-process the result of *find* with an *or-reduction*. Once you learn to spot the Atop-pattern, you'll see it's also common in APL code.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc5a022a",
   "metadata": {},
   "source": [
    "### Commute\n",
    "\n",
    "<div style=\"float: right; margin-left: 10px;\">\n",
    "    <img src=\"images/commute.png\" style=\"width:120px; height:auto; border: 1px solid #000000;\">\n",
    "</div>\n",
    "\n",
    "A multiplication table of `N` elements can be written as\n",
    "\n",
    "```apl\n",
    "(⍳⍵) ∘.× (⍳⍵)\n",
    "```\n",
    "\n",
    "Using the [Commute](https://help.dyalog.com/latest/index.htm#Language/Primitive%20Operators/Commute.htm) operator, we can avoid the repetition of `⍳⍵`:\n",
    "```apl\n",
    "∘.×⍨ ⍳⍵\n",
    "```\n",
    "\n",
    "Applying the derived function from the *Commute* operator monadically, we turn a dyadic function into a monadic function, by applying the argument on both sides. This is sometimes colloquially referred to as a \"selfie\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cefe720",
   "metadata": {},
   "source": [
    "### Examples\n",
    "\n",
    "Let's put these composition operators to work by rewriting some explicit expressions to tacit.\n",
    "\n",
    "Our first example does a case-insensitive equality check:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6a6d8825",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1\n",
       "</pre>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello' {(⎕C ⍺)≡(⎕C ⍵)} 'HELLO'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "179921df",
   "metadata": {},
   "source": [
    "Here we should be able to spot the fact that both arguments are pre-processed with `⎕C` to downcase before we match the results. This is a classic Over pattern -- match over case-fold:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2ca6fba7",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1\n",
       "</pre>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello' ≡⍥⎕C 'HELLO'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "751ef74c",
   "metadata": {},
   "source": [
    "Here's another. Check if all elements to the left argument are members of the right argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "24cc03af",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 0\n",
       "</pre>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ab' 'cd' {∧/⍺∊⍵}¨ 'abba' 'dad'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b89b5ab4",
   "metadata": {},
   "source": [
    "This can be rewritten neatly as an atop -- and-reduction atop member:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a5ff13a7",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 0\n",
       "</pre>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ab' 'cd' ∧/⍤∊¨ 'abba' 'dad'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22771671",
   "metadata": {},
   "source": [
    "The next example calculates the `⍵`<sup>th</sup> root of `⍺` by raising the left argument to the reciprocal power of the right:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6f00d754",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4 10 0\n",
       "</pre>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "64 1000 0 {⍺*÷⍵} 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57af80be",
   "metadata": {},
   "source": [
    "Putting this into words, we exponentiate (dyadic `*`) after *pre-processing* the right argument with the reciprocal (monadic `÷`). We should recognise this as the *beside* pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "67b307c3",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4 10 0\n",
       "</pre>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "64 1000 0 *∘÷ 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "657f61e6",
   "metadata": {},
   "source": [
    "Here's a function that multiplies the left argument with the signum of the right. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fedceeb8",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">¯10 4 0 0\n",
       "</pre>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 4 1 0 {⍺××⍵} ¯3 2 0 ¯1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44853c51",
   "metadata": {},
   "source": [
    "This is also a *beside*: multiply, after pre-processing the right argument with the signum function (monadic `×`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b1a8705b",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">¯10 4 0 0\n",
       "</pre>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 4 1 0 ×∘× ¯3 2 0 ¯1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c41ab92",
   "metadata": {},
   "source": [
    "## Introducing Trains\n",
    "\n",
    "Trains are also a type of function composition. A train is a sequence of functions in isolation. If used in-line, a train must be parenthesised:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a0d4f58f",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">2.8\n",
       "</pre>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(+⌿÷≢) 3 1 4 1 5 ⍝ Find the average"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cadf7774",
   "metadata": {},
   "source": [
    "A train can also be assigned, in which case we can skip the parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "12114e36",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">2.8\n",
       "</pre>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Avg ← +⌿÷≢\n",
    "Avg 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae03e7a3",
   "metadata": {},
   "source": [
    "### `fgh` Forks\n",
    "<div style=\"float: right; margin-left: 10px;\">\n",
    "    <img src=\"images/fgh.png\" style=\"width:240px; height:auto; border: 1px solid #000000;\">\n",
    "    <img src=\"images/fg.png\" style=\"width:240px; height:auto; border: 1px solid #000000;\">\n",
    "</div>\n",
    "\n",
    "\n",
    "Writing, and indeed reading, trains takes a bit of practice. Like for the compositional operators we explored above, it's a matter of recognise a set of common patterns. The `Avg` function we just looked at is an example of a monadic [Fork](https://help.dyalog.com/latest/index.htm#Language/Introduction/Trains.htm):\n",
    "\n",
    "\n",
    "```apl\n",
    "(f Y) + (h Y)  →  (f + h) Y\n",
    "```\n",
    "This pattern is sometimes referred to an `fgh` fork, which is a common compositional technique. \n",
    "\n",
    "What happens if we don't have an `h` function? Well, we can apply a neat trick using the *same* function (monadic `⊢`), which just returns its argument:\n",
    "\n",
    "```apl\n",
    "(f Y) + (  Y)  →  (f + ⊢) Y\n",
    "```\n",
    "\n",
    "If we only have the `g` and the `h` functions, the monadic `fgh` fork is the same as the corresponding explicit formulation (which is usually written as `fg`, not `gh`):\n",
    "\n",
    "```apl\n",
    "f (g Y)  →  (  f g) Y\n",
    "```\n",
    "In fact, this is another way to think of an atop.\n",
    "\n",
    "If `f` or `h` are *dyadic* functions, we get a similar fork pattern. In this case, the fork is applied dyadically:\n",
    "\n",
    "```apl\n",
    "(X f Y) + (X h Y)  →  X (f + h) Y\n",
    "```\n",
    "or, if we don't have an `f`, we use the *left* function (dyadic `⊣`) as the filler:\n",
    "\n",
    "```apl\n",
    "(X   ) + (X h Y)  →  X (⊣ + h) Y\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "304ea965",
   "metadata": {},
   "source": [
    "### `Agh` Forks and Longer Trains\n",
    "\n",
    "<div style=\"float: right; margin-left: 10px;\">\n",
    "    <img src=\"images/agh.png\" style=\"width:240px; height:auto; border: 1px solid #000000;\">\n",
    "    <img src=\"images/train45.png\" style=\"width:240px; height:auto; border: 1px solid #000000;\">\n",
    "</div>\n",
    "\n",
    "Not every component of a train has to be a function, but can also be arrays. These are sometimes called `Agh` forks. Their behaviour follows from the earlier `fgh` rules, with the addition that an array `A` is treated as the function `{A}`.\n",
    "\n",
    "Trains can be made longer by combining *forks* (`fgh` and `Agh`) and *atops* (`fg`). For example, \n",
    "\n",
    "- `(e f g h)` is treated as `(e (f g h))` -- a 4-train\n",
    "- `(d e f g h)` is treated as `(d e (f g h))` -- a 5-train\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cd97c5f",
   "metadata": {},
   "source": [
    "###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc33862a",
   "metadata": {},
   "source": [
    "### Writing a train\n",
    "\n",
    "Explicit expressions can be converted to tacit step-by-step. Here's a dfn that checks if the elements in a vector are in ascending order. We have three functions: \n",
    "\n",
    "- `∧/`\n",
    "- `⌈\\`\n",
    "- `=`\n",
    "\n",
    "and one array, `⍵`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9f87307b",
   "metadata": {
    "vscode": {
     "languageId": "apl"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1\n",
       "</pre>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{∧/ (⌈\\⍵) = ⍵}  1 3 5 6 7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35989423",
   "metadata": {},
   "source": [
    "Let's start with rewriting the \"naked\" array to the right of the equal sign using `same`, monadic `⊢`. Now we have four functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1b0de8dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1\n",
       "</pre>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{∧/ (⌈\\⍵) = (⊢⍵)}  1 3 5 6 7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5cf0a81",
   "metadata": {},
   "source": [
    "Now we have a `efgh` pattern. Let's gather the three right-most functions into the `fgh` form:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e51d0ec5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1\n",
       "</pre>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{∧/ (⌈\\ = ⊢) ⍵}  1 3 5 6 7 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99335c67",
   "metadata": {},
   "source": [
    "The inner fork doesn't need the parenthesis. We can group the whole train:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "35192315",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1\n",
       "</pre>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{(∧/ ⌈\\ = ⊢) ⍵}  1 3 5 6 7 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c753e20b",
   "metadata": {},
   "source": [
    "and, finally, remove the remaining `⍵` reference and the curly braces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ae58d277",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1\n",
       "</pre>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(∧/ ⌈\\ = ⊢)  1 3 5 6 7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa3d753c",
   "metadata": {},
   "source": [
    "### Examples\n",
    "\n",
    "Rewrite the following explicit expressions to tacit.\n",
    "\n",
    "**Example 1**\n",
    "\n",
    "Here's a dfn that multiplies its argument by 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6ebd5e1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4 14 2 16\n",
       "</pre>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{2×⍵} 2 7 1 8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db954172",
   "metadata": {},
   "source": [
    "We can do this tacitly in a couple of ways, either as an `Agh` train,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "998ba459",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4 14 2 16\n",
       "</pre>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2×⊢)2 7 1 8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eaea545",
   "metadata": {},
   "source": [
    "or as a bind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e3fd6f34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4 14 2 16\n",
       "</pre>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2∘× 2 7 1 8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ed63d9f",
   "metadata": {},
   "source": [
    "We can take a completely different tack by observing that multiplying something by two is the same as adding something to itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "644c224f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4 14 2 16\n",
       "</pre>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+⍨2 7 1 8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc882ec9",
   "metadata": {},
   "source": [
    "**Example 2**\n",
    "\n",
    "The following expression computes the [symmetric set difference](https://en.wikipedia.org/wiki/Symmetric_difference) between `⍺` and `⍵` as the union without the intersection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "63c589c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">3 4 6\n",
       "</pre>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 1 4 {(⍺∪⍵)~(⍺∩⍵)} 1 6 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b08507f",
   "metadata": {},
   "source": [
    "This is the dyadic `fgh` pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "a8e84cda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">3 4 6\n",
       "</pre>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 1 4 (∪~∩) 1 6 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dbf743d",
   "metadata": {},
   "source": [
    "**Example 3**\n",
    "\n",
    "This function finds the unique prime factors of the argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "0c65dc48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 2 5 10\n",
       "</pre>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{∪⍵∨⍳⍵} 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1137b0d",
   "metadata": {},
   "source": [
    "We have one \"naked\" `⍵`. Rewrite that first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "25ee5023",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 2 5 10\n",
       "</pre>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{∪(⊢⍵)∨⍳⍵} 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0589ae4",
   "metadata": {},
   "source": [
    "Now, hopefully, we can see the `efgh` pattern more clearly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "deb14aea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 2 5 10\n",
       "</pre>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(∪⊢∨⍳) 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16775ab1",
   "metadata": {},
   "source": [
    "We can also experss this with composition operators, but it's not quite as nice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "a0fc6068",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 2 5 10\n",
       "</pre>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(∪⍤∨∘⍳⍨) 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aaba381",
   "metadata": {},
   "source": [
    "**Example 4**\n",
    "\n",
    "The following expression returns the `⍺`<sup>th</sup> largest element of `⍵`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "78ed2ee4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4\n",
       "</pre>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 {(⍺⊃⍒⍵)⊃⍵} 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5986f79e",
   "metadata": {},
   "source": [
    "Rewrite the right-most `⍵` as `⍺⊢⍵` to give us the dyadic `fgh` pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "4ef829be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4\n",
       "</pre>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 {(⍺⊃⍒⍵)⊃(⍺⊢⍵)} 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e721b305",
   "metadata": {},
   "source": [
    "We have the `fgh` fork `f ⊃ ⊢`, where the `f` part is *pick* (`⊃`), pre-process right with *grade down* (`⍒`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b55c175b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4\n",
       "</pre>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 (⊃∘⍒⊃⊢) 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58a96a54",
   "metadata": {},
   "source": [
    "Note: we can't write this as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "998f68d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "RANK ERROR\n",
      "      2((⊣⊃⍒)⊃⊢)3 1 4 1 5 ⍝ RANK ERROR\n",
      "       ∧\n"
     ]
    }
   ],
   "source": [
    "2((⊣⊃⍒)⊃⊢)3 1 4 1 5 ⍝ RANK ERROR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4beb6de",
   "metadata": {},
   "source": [
    "as the `⍒` is now interpreted as dyadic. For that approach to work, we'd need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "7e1b9eb3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">4\n",
       "</pre>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2((⊣⊃⍒⍤⊢)⊃⊢)3 1 4 1 5 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbeecea2",
   "metadata": {},
   "source": [
    "## Tools\n",
    "\n",
    "There are several tools available that can be helpful when reading or writing tacit code. Let's look at the `]box` user command.\n",
    "\n",
    "### ]box on -t=…\n",
    "\n",
    "You're most likely aware already of `]box` -- a time-honoured mechanism for visual presentation of array structure in APL. Boxing is also helpful in investigating the structure of trains. You can specify the presentation style in several ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "80d25c67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">Was ON -trains=box\n",
       "</pre>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">┌─┬─────────────────┐\n",
       "│|│┌─┬─┬───────────┐│\n",
       "│ ││⊢│÷│┌─────┬─┬─┐││\n",
       "│ ││ │ ││┌─┬─┐│⍣│≡│││\n",
       "│ ││ │ │││+│/││ │ │││\n",
       "│ ││ │ ││└─┴─┘│ │ │││\n",
       "│ ││ │ │└─────┴─┴─┘││\n",
       "│ │└─┴─┴───────────┘│\n",
       "└─┴─────────────────┘\n",
       "</pre>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">Was ON -trains=box\n",
       "</pre>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">┌─┴─┐\n",
       "| ┌─┼─┐\n",
       "  ⊢ ÷ ⍣\n",
       "     ┌┴┐\n",
       "     / ≡\n",
       "   ┌─┘\n",
       "   +\n",
       "</pre>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">Was ON -trains=tree\n",
       "</pre>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">|(⊢÷((+/)⍣≡))\n",
       "</pre>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "]box on -trains=box\n",
    "\n",
    "|⊢÷+/⍣≡\n",
    "\n",
    "]box on -trains=tree\n",
    "\n",
    "|⊢÷+/⍣≡\n",
    "\n",
    "]box on -trains=parens\n",
    "\n",
    "|⊢÷+/⍣≡"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fb6bf57",
   "metadata": {},
   "source": [
    "Using `]box on -trains=…` shows the execution order of a train more explicitly. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e717cef",
   "metadata": {},
   "source": [
    "### tacit.help\n",
    "\n",
    "The website [tacit.help](https://tacit.help) is an excellent tool for converting a tacit expression into an explicit form. Type your tacit expression into the text box, and corresponding dfns will be generated, both monadic, and dyadic forms. \n",
    "\n",
    "Note: it cannot go the other way (explicit to tacit). Writing a tool to do this is left as an exercise for the interested reader. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cfb6b72",
   "metadata": {},
   "source": [
    "## More examples\n",
    "\n",
    "Practice makes perfect. Here is a batch of slightly more complex dfns for you to practice your tacit skills.\n",
    "\n",
    "**Example 1**\n",
    "\n",
    "This functions calculates the number of leading 1s in a Boolean vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "98c42d06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">3\n",
       "</pre>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{(⊖⍵)⊥⊖⍵} 1 1 1 0 1 1 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d7aff48",
   "metadata": {},
   "source": [
    "This looks like a straight-forward `fgh` fork, and of course it *can* be, but it's unnecessarily costly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "537de34b",
   "metadata": {},
   "outputs": [],
   "source": [
    "(⊖⊥⊖) 1 1 1 0 1 1 0 0 ⍝ Inefficient!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "320bab34",
   "metadata": {},
   "source": [
    "This approach calculates the reverse twice. We can resolve this with a *commute* (`⍨`) if we instead use the compositional operator *over* (`⍥`), either at the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "ed444b14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">3\n",
       "</pre>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(⊥⍥⊖⍨) 1 1 1 0 1 1 0 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfe1856c",
   "metadata": {},
   "source": [
    "or directly on the *decode* (`⊥`) itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "9a9f59a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">3\n",
       "</pre>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(⊥⍨⍥⊖) 1 1 1 0 1 1 0 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "164fdc54",
   "metadata": {},
   "source": [
    "There are alternative ways of formulating the solution, of course, such as summing the and-scan:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "d964aea9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">3\n",
       "</pre>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(+⌿∧⍀)1 1 1 0 1 1 0 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e46a350",
   "metadata": {},
   "source": [
    "The and-scan 'turns off' all 1s following the first 0."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27fbf8ec",
   "metadata": {},
   "source": [
    "**Example 2**\n",
    "\n",
    "This expression splits a right argument vector on every occurrence of a character in the left argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "a00d15eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">┌──┬──┬───┐\n",
       "│ab│de│fgh│\n",
       "└──┴──┴───┘\n",
       "</pre>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "',;' {(~⍵∊⍺)⊆⍵} 'ab,de;fgh'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d09f4983",
   "metadata": {},
   "source": [
    "First we address the 'naked' `⍵`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "00de0079",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">┌──┬──┬───┐\n",
       "│ab│de│fgh│\n",
       "└──┴──┴───┘\n",
       "</pre>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "',;' {(~⍵∊⍺)⊆(⍺⊢⍵)} 'ab,de;fgh'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26773e45",
   "metadata": {},
   "source": [
    "Almost a dyadic `fgh` fork, but the left 'tine' has the arguments the wrong way around. We can fix that with a *commute* (`⍨`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "bbcce1c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">┌──┬──┬───┐\n",
       "│ab│de│fgh│\n",
       "└──┴──┴───┘\n",
       "</pre>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "',;' {(~⍺∊⍨⍵)⊆(⍺⊢⍵)} 'ab,de;fgh'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60c26e22",
   "metadata": {},
   "source": [
    "The left tine can be simplified further by noting that we're post-processing (a.k.a. *atop*) the result with *not* (monadic `~`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "af4f5d2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">┌──┬──┬───┐\n",
       "│ab│de│fgh│\n",
       "└──┴──┴───┘\n",
       "</pre>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "',;' {(⍺~⍤∊⍨⍵)⊆(⍺⊢⍵)} 'ab,de;fgh'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ac1417a",
   "metadata": {},
   "source": [
    "Now we have a clean dyadic `fgh`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "fa71661c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">┌──┬──┬───┐\n",
       "│ab│de│fgh│\n",
       "└──┴──┴───┘\n",
       "</pre>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "',;' (~⍤∊⍨⊆⊢) 'ab,de;fgh'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c614263",
   "metadata": {},
   "source": [
    "**Example 3**\n",
    "\n",
    "Calculate the windowed averages of a numeric array, where `⍺` is the window size, and `⍵` the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "c51a8805",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">2.25 2.75\n",
       "</pre>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 {(⍺+⌿⍵)÷⍺} 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ec78314",
   "metadata": {},
   "source": [
    "We have a \"naked\" `⍺` this time. Let's get rid of that with a *left* (dyadic `⊣`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "ab17b653",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">2.25 2.75\n",
       "</pre>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 {(⍺+⌿⍵)÷(⍺⊣⍵)} 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a925f400",
   "metadata": {},
   "source": [
    "and the fork follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "d1ae3725",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">2.25 2.75\n",
       "</pre>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 (+⌿÷⊣) 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef73250",
   "metadata": {},
   "source": [
    "**Example 4**\n",
    "\n",
    "\n",
    "Calculate the average value of a numeric array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "d549062c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">2.8\n",
       "</pre>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{(+⌿⍵)÷≢⍵} 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cbe060d",
   "metadata": {},
   "source": [
    "Not much to do here! This is a commonly used example used to highlight how trains often track closely to the \"English\" description of the algorithm: sum (`+⌿`) and divide (`÷`) by the number of elements (`≢`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "15719d65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">2.8\n",
       "</pre>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(+⌿÷≢) 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53a468cc",
   "metadata": {},
   "source": [
    "**Example 5**\n",
    "\n",
    "The two previous functions are related -- we can think of Example 4 as a special case of Example 3, where the window size is equal to the length of the array. Can we combine these into a single, ambivalent function? Yes, we can!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "025cffab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">2.25 2.75\n",
       "</pre>"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">2.8\n",
       "</pre>"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 (+⌿÷⊣∘≢) 3 1 4 1 5\n",
    "(+⌿÷⊣∘≢) 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15decbdb",
   "metadata": {},
   "source": [
    "This is, in fact, the default expression given on [tacit.help](https://tacit.help). How does it work? The right tine of the fork ([⊣∘≢](https://tacit.help/?f=%E2%8A%A3%E2%88%98%E2%89%A2)) evaluates to `⍺` if called dyadically, and `≢⍵` if called mondadically. \n",
    "\n",
    "In the monadic case, both left and right tacks are the *same* function, return their argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "90268019",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">3 1 4 1 5\n",
       "</pre>"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">3 1 4 1 5\n",
       "</pre>"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊣3 1 4 1 5\n",
    "⊢3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "767b4237",
   "metadata": {},
   "source": [
    "so `⊣∘≢` is applying the *same* function (monadic `⊣`), after pre-processing the argument by *tally* (monadic `≢`), which just becomes *tally*, which is what we wanted.\n",
    "\n",
    "In the dyadic case, `⊣∘≢` again becomes pre-processing the right argument with the monadic *tally* function, and then applying the dyadic function *left* (dyadic `⊣`), which returns the left argument verbatim."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c691022e",
   "metadata": {},
   "source": [
    "## When to avoid tacit\n",
    "\n",
    "There are a few situations where tacit either can't be used, should be avoided, or requires extra care:\n",
    "\n",
    "- Arguments in operands\n",
    "- Sequences of monadic functions\n",
    "- Recursion, assignments, dotting\n",
    "- Selection (but see plans for v20.0)\n",
    "\n",
    "Let's examine them in detail."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8c6d390",
   "metadata": {},
   "source": [
    "### Arguments in operands\n",
    "\n",
    "If you're tacifying expressions where some function operands themselves take arguments, it can be difficult to convert the whole expression to tacit. Here's an example where we reverse all elements less than the left argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "52e84033",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 2 18 16 5 14 7 13\n",
       "</pre>"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 {x←⍺ ⋄ ⌽@{x<⍵}⍵} 1 2 13 14 5 16 7 18"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac95f2a4",
   "metadata": {},
   "source": [
    "We can't rewrite this completely to tacit, as the two instances of `⍵` refer to different scopes. We can, however, still benefit a bit from the techniques we've introduced above, by rewriting the operand function to `@` as tacit, thus no longer needing the temporary variable `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "fedaad79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 2 18 16 5 14 7 13\n",
       "</pre>"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 {⌽@(⍺<⊢)⍵} 1 2 13 14 5 16 7 18"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "298890b2",
   "metadata": {},
   "source": [
    "Following the same line of reasoning, here's a function that rotates an array around its centre, `⍺` times a quarter turn, clockwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "1db9b056",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">9 8 7\n",
       "6 5 4\n",
       "3 2 1\n",
       "</pre>"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 {(⌽⍤⍉⍣⍺)⍵} 3 3⍴⍳9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d146476",
   "metadata": {},
   "source": [
    "We can't tacit this completely."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cadc6677",
   "metadata": {},
   "source": [
    "### Sequences of monadic functions\n",
    "\n",
    "Where you have sequences primarily consisting of monadic function applications, tacit formulation, whilst not impossible, quickly becomes longer and uglier than the obvious explicit formulation. For example, consider\n",
    "\n",
    "```apl\n",
    "{⌽+⌿↑⌽¨⍵}\n",
    "```\n",
    "\n",
    "possible tacit formulations are:\n",
    "\n",
    "```apl\n",
    "⌽⍤(+⌿)⍤↑⍤(⌽¨)\n",
    "⌽(+⌿(↑⌽¨))\n",
    "⌽+⌿⍤↑⍤(⌽¨)\n",
    "⌽(+⌿⍤↑⌽¨)\n",
    "```\n",
    "\n",
    "neither of which particularly improves on the original."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fa0a106",
   "metadata": {},
   "source": [
    "### Three things tacit just cannot do\n",
    "\n",
    "A tacit expression cannot include\n",
    "\n",
    "- Assignment (`←`)\n",
    "- Namespace \"dotting\" (`a.b`)\n",
    "- Recursion (`∇`)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "494787d9",
   "metadata": {},
   "source": [
    "### Selection\n",
    "\n",
    "Selection is problematic. Consider *compress/replicate*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "962fdc65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 1\n",
       "</pre>"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{(3>⍵)⌿⍵} 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44fb0ec0",
   "metadata": {},
   "source": [
    "Tacit conversion looks trivial, right? Wrong."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "5329be05",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "SYNTAX ERROR: The function does not take a left argument\n",
      "      (3∘>⌿⊢)3 1 4 1 5 ⍝ SYNTAX ERROR\n",
      "      ∧\n"
     ]
    }
   ],
   "source": [
    "(3∘>⌿⊢)  3 1 4 1 5 ⍝ SYNTAX ERROR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbaf38f3",
   "metadata": {},
   "source": [
    "This is because `⌿` is a *hybrid* -- it can either be *compress/replicate* as a function, or *reduce-first* as an operator. Hybrids get interpreted as operators first, if at all possible. This means that we have to employ a non-obvious, ugly hoop-jump:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "5d33803e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 1\n",
       "</pre>"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3∘> ⊢⍤⌿ ⊢)3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7407bd3a",
   "metadata": {},
   "source": [
    "By having an operator to the left of `⌿`, it *must* be treated as a function. Thus, \"same atop compress-first\" can only be interpreted as the function compress-first. \n",
    "\n",
    "How do we fix this? The plan is to introduce a new operator, [behind/reverse-compose](https://aplwiki.com/wiki/Reverse_Compose) (`⍛`), in v20.0 of Dyalog APL. In the monadic case, we can model that as "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "90393c85",
   "metadata": {},
   "outputs": [],
   "source": [
    "∆←{(⍵⍵⍨∘⍺⍺⍨)⍵} ⍝ Behind/reverse-compose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f1bfef5",
   "metadata": {},
   "source": [
    "which enables us to write the *much* nicer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "fa3b9ae6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1 1\n",
       "</pre>"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3∘>∆⌿) 3 1 4 1 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e14f3e5",
   "metadata": {},
   "source": [
    "Bracket indexing doesn't work in trains, as it doesn't follow the normal function call conventions. Unfortunately, functional indexing, [squad](https://aplwiki.com/wiki/Index_(function)) (dyadic `⌷`) is a bit un-ergonomic. Let's say we want to sort a character vector based on a custom collating sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "1b9e241c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">eoohll wrld\n",
       "</pre>"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'aeiou' {⍵[⍺⍋⍵]} 'hello world'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c179cc49",
   "metadata": {},
   "source": [
    "It would be nice if we could write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "b91789c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LENGTH ERROR\n",
      "      'aeiou'{⍵⌷⍨⍺⍋⍵}'hello world' ⍝ LENGTH ERROR\n",
      "               ∧\n"
     ]
    }
   ],
   "source": [
    "'aeiou' {⍵⌷⍨⍺⍋⍵} 'hello world' ⍝ LENGTH ERROR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96ca06d7",
   "metadata": {},
   "source": [
    "instead of the clumsier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "9ac0390c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">eoohll wrld\n",
       "</pre>"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'aeiou' {⍵⌷⍨⊂⍺⍋⍵} 'hello world' ⍝ LENGTH ERROR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8317f9a",
   "metadata": {},
   "source": [
    "which, unfortunately, means that the tacit version has to become"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "edfea7a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">eoohll wrld\n",
       "</pre>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'aeiou'  (⊂⍤⍋⌷⊢)  'hello world'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cac5eff2",
   "metadata": {},
   "source": [
    "In v20.0, we're introducing a new primitive [select](https://aplwiki.com/wiki/From) (dyadic `⊇`), sometimes half-jokingly referred to as 'sane indexing'. It's modelled as "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "652a1c9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "I←⌷⍨∘⊃⍨⍤0 99"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b49c5b69",
   "metadata": {},
   "source": [
    "meaning that we'd get the rather nice tacit formulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "7d72f2c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">eoohll wrld\n",
       "</pre>"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'aeiou' (⍋I⊢) 'hello world' ⍝ I is select, ⊇"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8fafb04",
   "metadata": {},
   "source": [
    "## Tacit to explicit\n",
    "\n",
    "So far, we've focused on rewriting explicit expressions into tactit form. Sometimes you might want to do the reverse, so let's practice that on the following set of examples. The way to approach these is to remember the fact that every train consists of 3-trains (forks) and 2-trains (atops) going right to left. Or simply copy and paste into [tacit.help](https://tacit.help).\n",
    "\n",
    "**Example 1**\n",
    "```apl\n",
    "=∘⌊⍨ ⍝ monadic\n",
    "```\n",
    "\n",
    "This function checks which numbers in an array are integers. Equality, after the right argument is pre-processed by *floor* (monadic `⌊`), and the same argument to the left and right. This is:\n",
    "\n",
    "```apl\n",
    "{⍵=⌊⍵}\n",
    "```\n",
    "\n",
    "**Example 2**\n",
    "\n",
    "```apl\n",
    "××⌊⍤| ⍝ monadic\n",
    "```\n",
    "\n",
    "This is a fork. Starting from the right, we have \"floor atop absolute-value\" (`⌊⍤|`) as the right tine. The middle function is *multiply* (dyadic `×`) and the left tine is *signum* (monadic `×`). \n",
    "\n",
    "```apl\n",
    "{(×⍵) × ⌊|⍵}\n",
    "```\n",
    "\n",
    "**Example 3**\n",
    "```apl\n",
    "⌊∘≢↑⊢ ⍝ dyadic\n",
    "```\n",
    "\n",
    "Again a fork. Left tine is \"*min* (dyadic `⌊`), pre-process right with *tally* (monadic `≢`). Middle function is *take* (dyadic `↑`) and the right tine is *right* (dyadic `⊢`). This function caps the length of `⍵` to `⍺`, if smaller than `≢⍵`.\n",
    "\n",
    "```apl\n",
    "{(⍺⌊≢⍵) ↑ ⍵}\n",
    "```\n",
    "\n",
    "**Example 4**\n",
    "```apl\n",
    "≡⍥(⎕C~∘' ') ⍝ dyadic\n",
    "```\n",
    "\n",
    "This function does a case-insensitive comparison, after first removing all spaces.\n",
    "\n",
    "*Match* (dyadic `≡`), pre-process both with [case-convert](https://help.dyalog.com/latest/index.htm#Language/System%20Functions/c.htm) (monadic `⎕C`) *without* (dyadic `~`) space. We'll factor out the pre-process function as a local dfn:\n",
    "\n",
    "```apl\n",
    "{f ← {⎕C⍵~' '} ⋄ (f⍺)≡f⍵}\n",
    "```\n",
    "\n",
    "**Example 5**\n",
    "```apl\n",
    "+⌿⊢>+⌿÷≢ ⍝ monadic\n",
    "```\n",
    "\n",
    "Wow. Deep breath. From the right, the first three functions make up a fork: `+⌿÷≢` which we probably by now recognise as the *average*. Let's temorarily name that `F`.\n",
    "\n",
    "```apl\n",
    "F ← {(+⌿⍵)÷≢⍵}\n",
    "+⌿ ⊢>F ⍝ monadic\n",
    "```\n",
    "Again, take the three right-most functions and form the next fork: *same* *greater-than* *Avg*. *Same* in this case just means `⍵`, so we can add this comparison to our `F` function:\n",
    "\n",
    "```apl\n",
    "F ← {⍵>(+⌿⍵)÷≢⍵}\n",
    "+⌿ F ⍝ monadic\n",
    "```\n",
    "and what remains is to inline the final atop:\n",
    "\n",
    "```apl\n",
    "F ← {+⌿ ⍵>(+⌿⍵)÷≢⍵}\n",
    "```\n",
    "\n",
    "**Example 6**\n",
    "```apl\n",
    "+∘÷⍣≡ ⍝ dyadic\n",
    "```\n",
    "This calculates the [golden ratio](https://en.wikipedia.org/wiki/Golden_ratio). Not much to do here; only the left operand of the *power* (`⍣`) operator, which is a *beside* -- sum after pre-processing the right argument with *reciprocal* (monadic `÷`):\n",
    "\n",
    "```apl\n",
    "{⍺+÷⍵}⍣≡\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "507cbc69",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">1.618033989\n",
       "</pre>"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 (+∘÷⍣≡) 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0da529a",
   "metadata": {},
   "source": [
    "## Persistent hash tables\n",
    "\n",
    "A neat, but perhaps lesser-known, feature of Dyalog APL is that under certain circumstances, a subset of primitives will maintain a hash table for subsequent lookups that can boost performance. One way to inform the interpreter that you want to do multiple lookups -- and so would benefit from a persistent hash table -- is to bind an array to a lookup primitive, and tacit formulations make this convenient.\n",
    "\n",
    "The following primitives support this style:\n",
    "\n",
    "| Not hashed | Hashed |\n",
    "----------|-----|\n",
    "|`P ⍋ s` | `P∘⍋ s`|\n",
    "|`P ⍒ s` | `P∘⍒ s`|\n",
    "|`P ⍳ s` | `P∘⍳ s`|\n",
    "|`P ∪ s` | `P∘∪ s`|\n",
    "|`s ∊ P` | `(∊∘P) s`|\n",
    "|`s ~ P` | `(~∘P) s`|\n",
    "|`s ∩ P` | `(∩∘P) s`|\n",
    "\n",
    "\n",
    "Creating and maintaining a hash table has a cost associated with it, so it's not always clear-cut if it's worthwhile. We can compare the performance of hashed and unhashed versions of dyadic iota and dyadic grade if we pre-populate the hash before the comparison itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "8cf32558",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">  ⎕AV⍳s → 3.8E¯7 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕\n",
       "  AVi s → 2.8E¯7 | -27% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕           \n",
       "</pre>"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'cmpx'⎕CY'dfns'\n",
    "s←'Hello, World!'\n",
    "AVi←⎕AV∘⍳ ⋄ {}AVi s\n",
    "cmpx '⎕AV⍳s' 'AVi s'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "c8eb9e3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">  ⎕AV⍋s → 1.2E¯6 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕\n",
       "  AVg s → 2.4E¯7 | -81% ⎕⎕⎕⎕⎕⎕⎕⎕                                \n",
       "</pre>"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AVg←⎕AV∘⍋ ⋄ {}AVg s\n",
    "cmpx '⎕AV⍋s' 'AVg s'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e59f383",
   "metadata": {},
   "source": [
    "However, if we take the creation of the hash table itself into account, the results look rather different:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "a5872aaf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">  ⎕AV⍳s   → 4.3E¯7 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕                   \n",
       "  ⎕AV∘⍳ s → 8.1E¯7 | +87% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕\n",
       "</pre>"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cmpx '⎕AV⍳s' '⎕AV∘⍳ s'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "8e68526b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=\"language-APL\">  ⎕AV⍋s   → 1.3E¯6 |     0% ⎕⎕⎕                                     \n",
       "  ⎕AV∘⍋ s → 1.9E¯5 | +1400% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕\n",
       "</pre>"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cmpx '⎕AV⍋s' '⎕AV∘⍋ s'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b393a090",
   "metadata": {},
   "source": [
    "The cost of creating the hash is likely only worth it if you intend to do many lookups."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4e805a3",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "Here is a handy little cheat-sheet:\n",
    "\n",
    "**Compositional operators**:\n",
    "- `⍥` Pre-process both\n",
    "- `∘` Pre-process right\n",
    "- `⍤` Post-process result\n",
    "- `⍨` Selfie\n",
    "\n",
    "**Operators**: long left scope\n",
    "\n",
    "**Trains**: odd-even from right\n",
    "\n",
    "**Tools**:\n",
    "- `]box on -t=…`\n",
    "- [tacit.help](https://tacit.help)\n",
    "\n",
    "**Watch out for these**:\n",
    "- Arguments in operands\n",
    "- Lots of monadic functions\n",
    "\n",
    "**Don’t try**:\n",
    "- Assignment\n",
    "- Namespace “dotting”\n",
    "- Recursion\n",
    "\n",
    "**Selection issues**:\n",
    "- Compress: `⊢⍤⌿`\n",
    "- Index: `⊂⍤… ⌷ …`\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Dyalog APL",
   "language": "apl",
   "name": "dyalog-kernel"
  },
  "language_info": {
   "file_extension": ".apl",
   "mimetype": "text/apl",
   "name": "APL"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}