contents/find.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding things\n",
    "\n",
    "> Computer languages of the future will be more concerned with goals and less with procedures specified by the programmer.\n",
    "\\--_Marvin Minsky_\n",
    "\n",
    "Just like with indexing, there seems to be a baffling array of ways to locate items in arrays in APL. As stated in [The Zen of Python](https://zen-of-python.info/): \n",
    "\n",
    "> There should be one-- and preferably only one --obvious way to do it.\n",
    "\n",
    "Aha. About that...\n",
    "\n",
    "![laugh](https://media.giphy.com/media/JmD9mkDmzvXE7nxy7j/giphy-downsized-medium.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">Was ON\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">Was OFF\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕IO ← 0\n",
    "]box on\n",
    "]rows on"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Equality `=`\n",
    "\n",
    "So how do you locate where an element resides in an array in APL? Well, the obvious way to do it is to exploit equality and scalar extension. Where is the number 2?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌→────────────────────────────────────────────────────────────────┐\n",
       "↓0 0  0  0  0  0  0 0  0  0  0 1  0  0 0  0 0  0  0  0 0 0 0  0  0│\n",
       "│4 1 22 20 16 10 25 7 18 11 15 2 12 23 9 17 6 14 21 19 3 8 5 13 24│\n",
       "└~────────────────────────────────────────────────────────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "]DISPLAY ↑(2=data)(data ← 4 1 22 20 16 10 25 7 18 11 15 2 12 23 9 17 6 14 21 19 3 8 5 13 24)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's surely sufficiently _Zen_ in the _Zen of Python_ sense. Hands up every item that equals 2. We can find out the actual index, too, by using _Iota underbar_, `⍸`, which in its monadic form is appropriately enough called [_Where_](https://help.dyalog.com/18.0/index.htm#Language/Primitive%20Functions/Where.htm):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">11\n",
       "</span>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍸2=data ⍝ Where is data = 2?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we should expect by now, scalar extension lets scalar functions penetrate any level of nesting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───────────┬─────────────┐\n",
       "│┌─┬─┬─────┐│┌─┬─────────┐│\n",
       "││1│2│3 4 5│││4│┌─┬─┬───┐││\n",
       "│└─┴─┴─────┘││ ││1│2│3 4│││\n",
       "│           ││ │└─┴─┴───┘││\n",
       "│           │└─┴─────────┘│\n",
       "└───────────┴─────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───────────┬─────────────┐\n",
       "│┌─┬─┬─────┐│┌─┬─────────┐│\n",
       "││0│0│0 1 0│││1│┌─┬─┬───┐││\n",
       "│└─┴─┴─────┘││ ││0│0│0 1│││\n",
       "│           ││ │└─┴─┴───┘││\n",
       "│           │└─┴─────────┘│\n",
       "└───────────┴─────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕ ← nested ← (1 2 (3 4 5))(4 (1 2(3 4)))\n",
    "4=nested"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Match `≡`\n",
    "\n",
    "[_Match_](http:https://help.dyalog.com/18.0/index.htm#Language/Primitive%20Functions/Where.htm) we've already met. It is like equality but for non-scalar things. You can be forgiven to think that if you look for a particular vector in a vector-of-vectors, you should be able to use equality, but that doesn't work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LENGTH ERROR\n",
      "      'ccc'=strings  ⍝ LENGTH ERROR!\n",
      "           ∧\n"
     ]
    }
   ],
   "source": [
    "strings ← 'aaa' 'bbb' 'ccc' 'ddd' 'ccc' 'aaa' 'ccc' 'bbb'\n",
    "'ccc'=strings  ⍝ LENGTH ERROR!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead we need either _Jot match each_ (`∘≡¨`) or _Enclose match each_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3 5 7\n",
       "</span>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3 5 7\n",
       "</span>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍸'ccc'∘≡¨strings\n",
    "⍸(⊂'ccc')≡¨strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Index of `A⍳B`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way we can find the index of things is via [_Index of_](http:https://help.dyalog.com/18.0/index.htm#Language/Primitive%20Functions/Index%20Of.htm), dyadic `⍳`, which we have actually met before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">12\n",
       "</span>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data⍳2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dyadic _iota_ finds the _first_ index - or 1 plus the last index if not found. This has the nice feature that we can feed it an array to the right:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">12 21\n",
       "</span>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data⍳2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...which, if we want to use equality requires a bit more dexterity -- but this approach would also spot multiples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "VALUE ERROR: Undefined name: data\n",
      "      ⍸∨⌿2 3∘.=data\n",
      "               ∧\n"
     ]
    }
   ],
   "source": [
    "⍸∨⌿2 3 ∘.= data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about if we crank the rank a bit?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\"> 2 15 16 14\n",
       "11  9 12 10\n",
       "13  1  7  5\n",
       " 4  8  6  3\n",
       "</span>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕ ← mat ← 4 4⍴2 15 16 14 11 9 12 10 13 1 7 5 4 8 6 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0\n",
       "0 0 0 0\n",
       "0 0 1 0\n",
       "0 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┐\n",
       "│3 3│\n",
       "└───┘\n",
       "</span>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕ ← mask ← 7=mat\n",
    "⍸mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gotta love APL. \n",
    "\n",
    "## Find `⍷`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is of course also a glyph that's called [_Find_](http:https://help.dyalog.com/18.0/index.htm#Language/Primitive%20Functions/Find.htm) (`⍷`) which locates the start-points of subsequences:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 0 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ana' ⍷ 'banana'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That combines nicely with `⍸` as a tacit atop to give a bit of an idiom to commit to memory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 3\n",
       "</span>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "substr ← ⍸⍷\n",
    "'ana' substr 'banana'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use find to locate arrays-in-arrays of higher ranks, too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌→──┐\n",
       "↓0 1│\n",
       "│1 0│\n",
       "└~──┘\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌→──────┐\n",
       "↓0 1 0 0│\n",
       "│1 0 0 1│\n",
       "│0 0 1 0│\n",
       "│0 1 0 0│\n",
       "└~──────┘\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "]DISPLAY needle ← 2 2⍴0 1 1 0\n",
    "]DISPLAY haystack ← 4 4⍴0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 0 0\n",
       "0 0 1 0\n",
       "0 1 0 0\n",
       "0 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "needle ⍷ haystack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 1s represent the top-left corners of the 'needle' array in 'haystack':"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![find1](./IMG/find1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and we can pick out the actual coordinates using the same idiom we used for `substring` above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌→──────────────────┐\n",
       "│ ┌→──┐ ┌→──┐ ┌→──┐ │\n",
       "│ │0 0│ │1 2│ │2 1│ │\n",
       "│ └~──┘ └~──┘ └~──┘ │\n",
       "└∊──────────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "needle (⍸⍷) haystack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regular expessions\n",
    "\n",
    "Dyalog supports regular expressions through the most excellent [PCRE](http:https://help.dyalog.com/18.0/index.htm#Language/Appendices/PCRE%20Regular%20Expression%20Details.htm) engine. Dyalog's docs on the topic can be found [here](http:https://help.dyalog.com/18.0/index.htm#Language/System%20Functions/r.htm), and an APL Orchard cultivation was dedicated to the [topic](https://chat.stackexchange.com/rooms/52405/conversation/lesson-24-r-and-s), too. How regexes themselves work is beyond the scope of this book, but an exceptional reference that belongs on every programmer's bookshelf is Jeffrey Friedl's [Mastering Regular Expressions](http:https://regex.info/book.html).\n",
    "\n",
    "Let's take a brief look at how regexes are integrated in Dyalog.\n",
    "\n",
    "Two system operators, `⎕S` and `⎕R`, implement regex search and replace respectively. They're both dyadic operators, taking regular expression(s) to the left and transformation(s) to the right. The derived function can be applied to text data.\n",
    "\n",
    "Here's a simple example. Using a transformation string of `&`, `⎕S` returns a vector of what was matched:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┬─────┐\n",
       "│llo w│ll  w│\n",
       "└─────┴─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ll.\\sw'⎕S'&' ⊢ 'hello world well  worn'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The left operand can be a nested vector of regexes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌→─────────────────────────┐\n",
       "│ ┌→─┐ ┌→─┐ ┌→─┐ ┌→─┐ ┌→─┐ │\n",
       "│ │he│ │ll│ │wo│ │ll│ │wo│ │\n",
       "│ └──┘ └──┘ └──┘ └──┘ └──┘ │\n",
       "└∊─────────────────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'he' 'wo' 'll'⎕S'&' ⊢ 'hello world well  worn'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The right operand can be a function, too. This is where it gets a bit <s>hairy</s> flexible. We could have written the above as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──┬──┬──┬──┬──┐\n",
       "│he│ll│wo│ll│wo│\n",
       "└──┴──┴──┴──┴──┘\n",
       "</span>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'he' 'wo' 'll'⎕S{⍵.Match}'hello world well  worn'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, the right operand function gets passed a _namespace_ representing the match at that point. In this case, the `⍵.Match` holds \"what the current regex matched\" - the same as the magic transformation short-hand `'&'`. \n",
    "\n",
    "\n",
    "For capture groups, we have numbered references `'\\1', '\\2'` etc, as per Perl:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬─────┬────┐\n",
       "│aaa│bbbbb│aaaa│\n",
       "└───┴─────┴────┘\n",
       "</span>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'(a{2,}|b{2,})'⎕S'\\1' ⊢'aaabababbbbbaaaa'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using a function operand, we have the opportunity to apply the full might of APL to the matches. Let's find stretches of 2 or longer of `a` or `b`, and turn them to upper-case (using [_Case convert_, `⎕C`](http:https://help.dyalog.com/18.0/index.htm#Language/System%20Functions/c.htm)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬─────┬────┐\n",
       "│AAA│BBBBB│AAAA│\n",
       "└───┴─────┴────┘\n",
       "</span>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'(a{2,}|b{2,})'⎕S{1⎕C ⍵.Match}'aaabababbbbbaaaa'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The regex replacement operator, `⎕R`, operates much in the same way, but here the right operand represents a substitution into the right argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">AbAbAbAdAbAAbA\n",
       "</span>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a(.)a'⎕R'A\\1A'⊢'abababadabaaba' ⍝ \\1 is the first capture group"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A handy trick is to split strings based on a regular expression, removing the separators in the process. This is tricker than you might guess in Dyalog. Here's what [APL Cart](https://aplcart.info/?q=regex%20split#) suggests:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">Rebuilding user command cache... done\n",
       "\n",
       "Rebuilding user command cache... done\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsplit ← {(⊢/¨r)↓¨⍵⊂⍨(⍳≢⍵)∊1+⊃¨r←(⍺,'|^')⎕S 0 1⊢⍵} ⍝ APL Cart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌────┬───┬────┬───┬┐\n",
       "│aaaa│bbb│cccc│eee││\n",
       "└────┴───┴────┴───┴┘\n",
       "</span>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'\\d+' rsplit 'aaaa6666bbb1cccc999eee87'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the empty segment at the end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overlapping matches\n",
    "\n",
    "In normal operations, a regex \"consumes\" what it matches, and any susbequent matches will start where the previous one ended. For example, if we want to capture pairs of letters starting with an `a`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──┬──┐\n",
       "│ab│aa│\n",
       "└──┴──┘\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a.'⎕S'&'⊢'abaac' ⍝ Won't return ab aa ac"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which won't capture the last pair `ac` as it overlaps with the previous match `aa`. If we want to capture potentially overlapping matches, we have two options. Option 1 is the time-honoured technique borrowed from Perl, using a capture group inside a [_zero-width lookahead assertion_](https://www.regular-expressions.info/lookaround.html):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──┬──┬──┐\n",
       "│ab│aa│ac│\n",
       "└──┴──┴──┘\n",
       "</span>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'(?=(a.))'⎕S'\\1'⊢'abaac'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zero-width lookaheads (and lookbehinds) work just like normal patterns, except that they don't _consume_ what they match.\n",
    "\n",
    "Option 2 is to tell the regex engine that we want to allow overlapping matches via a [_Variant_](http:https://help.dyalog.com/18.0/index.htm#Language/Primitive%20Operators/Variant.htm) (`⍠`) setting to `⎕S`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──┬──┬──┐\n",
       "│ab│aa│ac│\n",
       "└──┴──┴──┘\n",
       "</span>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a.'⎕S'&'⍠'OM'1⊢'abaac' "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is both elegant and clear: variant `OM` is _Overlapping Matches_. See the [docs](http:https://help.dyalog.com/18.0/index.htm#Language/System%20Functions/r.htm) for more details on the various options that can be enabled with _Variant_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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": 4
}