Verbs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Built-in verbs\n",
    "\n",
    "K (depending on generation) has around 20 built-in verbs. A complication is that they typically have multiple meanings, depending on both context and arity. Indeed, a significant part of the effort required to learn to read k is to be able to recognise the overloaded meanings of verbs and adverbs depending on context. \n",
    "\n",
    "What _is_ a verb? In other languages, much of the functionality that hides behind k's verbs (and adverbs) tend to be functions residing in various libraries. Indeed, in Python you'd probably need at least half a dozen `import` statements to match k's built-in verbs and adverbs. It follows that instead of thinking of k as a language with no libraries, you can think of it as a tiny language providing an extremely compact way of accessing a very complete standard library.\n",
    "\n",
    "`ngn/k` has 22 built-in verbs: `: + - * % ! & | < > = ~ , ^ # _ $ ? @ . 0: 1:`, most of which have both monadic and dyadic versions, and occasionally different meanings depending on the types of arguments. This chapter runs through the majority of the built-in verbs in turn, briefly. Think of it as the annotated ref-card (`\\+`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "K has a strict right-to-left order of evaluation, like all Iversonian languages. If you're not used to this, it's sure to bite you sooner or later, but it's really intended as a simplification, and as such it soon comes naturally. However, behold:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "1+5*2-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Had you tapped that out on a calculator you would have gotten a different result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "1+(5*2)-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With k's strict right-to-left evaluation order and no differences in precedence, you need to place explicit parentheses if you want the multiplication to \"come first\". It follows that you really need to consider a snippet of k-code from right to left. \n",
    "\n",
    "As k's verbs usually comes in both monadic and dyadic forms, we must also consider the scope of argument binding. To the right it's usually obvious: a verb's right argument is the result of everything to its right. To the left, the binding extends as far as possible, whilst staying true to the right-to-left rule. For example, in the expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1 -2 -1 6 5\n"
     ]
    }
   ],
   "source": [
    "4 3 2 5 6 + 3 2 1 2 1 - 8 7 4 1 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But first, the promised run-down of the built-ins."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dex, assign `:`\n",
    "\n",
    "Dex, dyadic `:`, also called `right`, returns its right argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"world\"\n"
     ]
    }
   ],
   "source": [
    "\"hello\":\"world\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If used monadically, it still returns its right argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "57\n"
     ]
    }
   ],
   "source": [
    ":57"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the left side is a variable name, it becomes assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "a:1 2 3 4    / assignment\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flip, add `+`\n",
    "\n",
    "Monadic `+` is `flip` or `transpose`. It flips the axes of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1 2 3 4 5\n",
      " 6 7 8 9 10)\n",
      "(1 6\n",
      " 2 7\n",
      " 3 8\n",
      " 4 9\n",
      " 5 10)\n"
     ]
    }
   ],
   "source": [
    ":a:(1 2 3 4 5;6 7 8 9 10)   / leading : for display purposes\n",
    "+a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flip will \"broadcast\" atoms, but otherwise the matrix cannot be \"ragged\", which incurs a length error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1 0\n",
      " 2 0\n",
      " 3 0\n",
      " 4 0\n",
      " 5 0\n",
      " 6 0)\n",
      "'length\n",
      " +(1 2 3 4 5 6;0 1)   / length error\n",
      " ^\n"
     ]
    }
   ],
   "source": [
    "+(1 2 3 4 5 6;0)     / broadcast atom\n",
    "+(1 2 3 4 5 6;0 1)   / length error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dyadic `+` is `add`. No surprises there:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 9 10 11\n"
     ]
    }
   ],
   "source": [
    "1 2 3 4 + 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add is _atomic_; it will drill down and apply at the atom level in nested structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Negate, subtract `-`\n",
    "\n",
    "Monadic `-` negates its argument, and in its dyadic form, it subtracts.  Note the ambiguity. Negation binds tight, so that we can specify negative literals:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1 2 3 4 5 6\n",
      "-1 -2 -3 -4 -5 -6\n",
      "1 2 3 -4 5 6\n",
      "-3 -3 -3\n"
     ]
    }
   ],
   "source": [
    "-1 2 3 4 5 6     / negate only the first element\n",
    "- 1 2 3 4 5 6    / negate list\n",
    "1 2 3 -4 5 6     / negative literal\n",
    "1 2 3 - 4 5 6    / subtraction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First, multiply `*`\n",
    "\n",
    "Monadic `*` is _first_. It returns the first item of the right argument, or the argument itself if it's an atom:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "\"h\"\n",
      "\"hello\"\n",
      "`sym\n"
     ]
    }
   ],
   "source": [
    "*1 2 3\n",
    "*\"hello, world\"\n",
    "*(\"hello\";\"world\")\n",
    "*`sym"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the argument is a dict, it returns the first of the values (recall that a dict is ordered):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "*`a`b`c!1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dyadic `*` is normal multiplication:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "411303267.32\n"
     ]
    }
   ],
   "source": [
    "5438.8*75623.9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like _add_, _multiply_ is also atomic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Square root, divide `%`\n",
    "\n",
    "Monadic `%` is square root, and the dyadic form is division, both atomic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n",
      "3.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "%2     / √2\n",
    "10%3   / 10÷3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1.4142135623730951 2.6457513110645907 2.0 3.1622776601683795 3.0\n",
      " 2.449489742783178 2.23606797749979 3.0 8.06225774829855 6.4031242374328485)\n"
     ]
    }
   ],
   "source": [
    "%(2 7 4 10 9;6 5 9 65 41)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enum, odometer, keys, etc `!`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The exclamation mark is hideously overloaded. In its monadic form, it's either _interval_, _odometer_, or _keys_, depending on the argument's type. If the argument is a scalar integer, we have _interval_ (or _enum_, _range_, _index generator_ etc). It generates the range 0 to `n-1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9\n"
     ]
    }
   ],
   "source": [
    "!10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the argument is a numeric _vector_, we get _odometer_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2\n",
      " 0 0 0 1 1 1 2 2 2 0 0 0 1 1 1 2 2 2 0 0 0 1 1 1 2 2 2\n",
      " 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2)\n"
     ]
    }
   ],
   "source": [
    "!3 3 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It basically counts up like a car's mileage meter, if you look at the columns. The indexes generated by odometer defines the different ways you can pick items from a set with replacement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the argument is a dict, we get the keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`eric`bob`amy`joan\n"
     ]
    }
   ],
   "source": [
    "d:`eric`bob`amy`joan!234 67 52 98\n",
    "!d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It will also return keys from a namespace, but we won't cover those.\n",
    "\n",
    "In the dyadic form we either have the dict constructor we saw in the cell above, or div/mod:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "-2!28      / div\n",
    "2!29       / mod"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That probably feels weird, with the numerator and denominator \"back to front\", and using a negative number to distinguish between the two operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Where, min, and `&`\n",
    "\n",
    "Monadic `&` is called _where_ and is aptly named: if the argument is a Boolean vector, it gives the indexes of non-zero values of a vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5\n"
     ]
    }
   ],
   "source": [
    "&0 0 1 1 0 1 0        / where are the 1s?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the argument is a non-Boolean integer vector, it returns a repeated instance of the index of each non-zero element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 4 4 4 4 8 8\n"
     ]
    }
   ],
   "source": [
    "&0 0 0 0 5 0 0 0 2    / 5 of index 4, 2 of index 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a dyad, it's either `and` or `min`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1 2 3 4 5 5 5 5 5\n"
     ]
    }
   ],
   "source": [
    "5&7                   / min \n",
    "5&1 2 3 4 5 6 7 8 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the arguments are Boolean, we have Boolean _AND_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1 0 0 1 0 0 0 0 1 0\n"
     ]
    }
   ],
   "source": [
    "(2>8)&7<10\n",
    "1 0 1 1 0 1 0 0 1 1&1 1 0 1 1 0 0 0 1 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reverse, max, or `|`\n",
    "\n",
    "Monadic `|` is _reverse_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 4 3 2 1\n",
      "((4 5 6;7 8 9)\n",
      " 1 2 3)\n",
      "`sym\n",
      "`c`b`a!3 2 1\n"
     ]
    }
   ],
   "source": [
    "|1 2 3 4 5                 / simple list\n",
    "|(1 2 3;(4 5 6;7 8 9))     / nested list\n",
    "|`sym                      / atom\n",
    "|`a`b`c!1 2 3              / dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dyadically, it is analogous to dyadic `&` above. For non-Boolean arguments, it's _max_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "5 5 5 5 5 6 7 8 9\n"
     ]
    }
   ],
   "source": [
    "5|7                        / max\n",
    "5|1 2 3 4 5 6 7 8 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and for Boolean arguments, it's _or_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1 1 1 1 1 1 0 0 1 1\n"
     ]
    }
   ],
   "source": [
    "(2>8)|7<10\n",
    "1 0 1 1 0 1 0 0 1 1|1 1 0 1 1 0 0 0 1 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grade up/down, less than/greater than `<>`\n",
    "\n",
    "Dyadically, `<` and `>` do what you expect. Monadically, they're k's _grade up/down_. The grades give an index permutation, that, if used for selection, would order the argument either in ascending or descending order: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 18 5 12 15 8 1 11 13 0 6 2 4 16 3 14 9 17 19 7\n",
      "0 2 3 3 3 4 5 5 6 7 8 10 10 11 12 15 16 16 17 18\n"
     ]
    }
   ],
   "source": [
    "v:7 5 10 12 10 3 8 18 4 16 0 5 3 6 15 3 11 16 2 17\n",
    "\n",
    "<v                / grade up\n",
    "v[<v]             / select on grade up, a.k.a sort in ascending order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It works for dicts, too. Grading a dict will give a _key_ permutation vector that, if used for selection, would order the values accordingly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`k`s`f`m`p`i`b`l`n`a`g`c`e`q`d`o`j`r`t`h\n",
      "0 2 3 3 3 4 5 5 6 7 8 10 10 11 12 15 16 16 17 18\n"
     ]
    }
   ],
   "source": [
    "k:`a`b`c`d`e`f`g`h`i`j`k`l`m`n`o`p`q`r`s`t\n",
    "v:7 5 10 12 10 3 8 18 4 16 0 5 3 6 15 3 11 16 2 17\n",
    "d:k!v\n",
    "\n",
    "<d               / grade up\n",
    "d[<d]            / select on grade up, a.k.a sort in ascending order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Group, unit mat, equals `=`\n",
    "\n",
    "Mondadic `=` is either the super-useful _group_ (if the argument is a vector), or _unitmat_ -- make an identity matrix, if the argument is an integer atom. Group, first, takes a vector and returns a dict, mapping each unique element to their corresponding indexes of occurrence. This can be used to build frequency tables or histograms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"misp\"!(,0;1 4 7 10;2 3 5 6;8 9)\n"
     ]
    }
   ],
   "source": [
    "=\"mississippi\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other case is making the identity matrix of any size:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1 0 0\n",
      " 0 1 0\n",
      " 0 0 1)\n",
      "(1 0 0 0 0\n",
      " 0 1 0 0 0\n",
      " 0 0 1 0 0\n",
      " 0 0 0 1 0\n",
      " 0 0 0 0 1)\n"
     ]
    }
   ],
   "source": [
    "=3\n",
    "=5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dyadically, it's the familiar equality operator, which is fully atomic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 1 0 0 1 0 0 0 1 0\n"
     ]
    }
   ],
   "source": [
    "5=9 7 5 2 3 5 6 9 8 5 7    / hands up if you're a 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Match, not `~`\n",
    "\n",
    "Monadic `~` is Boolean NOT. It flips 0 to 1, and 1 (for some definition of 1) to 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 0 0 1 1 1 1 0\n"
     ]
    }
   ],
   "source": [
    "~1 0 0 1 1 0 0 0 0 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For emphasis, not just Boolean vectors -- it treats anything non-zero as truthy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 0 1 1 0 1 0 1 0 0 0 0\n"
     ]
    }
   ],
   "source": [
    "~2 0 8 0 0 9 0 8 0 8 6 6 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dyadically, it's _match_ -- deep equals. True if both shape and content are equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "(1 0 0 1;0 1 0 1)~(1 0 0 1;0 1 0 1)\n",
    "(1 0 0 1;(0 1;0 1))~(1 0 0 1;0 1 0 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enlist, concat `,`\n",
    "\n",
    "Monadic `,` turns its argument into a vector with a depth of +1 of what it was:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ",1\n",
      ",1 2 3\n"
     ]
    }
   ],
   "source": [
    ",1\n",
    ",1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "K's display makes depth a bit harder to see, but we can show it by counting the elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#1 2 3\n",
    "#,1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dyadically, it's _concat_ -- glue vectors together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 7 8 9 10\n"
     ]
    }
   ],
   "source": [
    "a:1 2 3 4\n",
    "b:7 8 9 10\n",
    "\n",
    "a,b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that k, unlike APL, has no concept of _stranding_. In other words, we can't combine vectors simply by separating them with spaces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0N 0N 0N 0N\n"
     ]
    }
   ],
   "source": [
    "a:1 2 3 4\n",
    "b:7 8 9 10\n",
    "\n",
    "a b            / note: no stranding! this is interpreted as a@b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That last expression is equivalent to `a@b`, which is the same as `a[b]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fill, without, null `^`\n",
    "\n",
    "Mondadic `^` is _null_: it returns true if something is null."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "^0N"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's most useful when applied to vectors that may have nulls interspersed, to \"spot the holes\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0 0 1 0 0 1 0 0\n"
     ]
    }
   ],
   "source": [
    "^9 8 3 5 0N 54 98 0N 67 53    / where are the nulls?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dyadically, if the left argument is an atom, we can use it as _fill_ -- find nulls, and replace them with this value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 8 3 5 99 54 98 99 67 53\n"
     ]
    }
   ],
   "source": [
    "99^9 8 3 5 0N 54 98 0N 67 53  / replace nulls with 99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If both arguments are vectors, we have _without_ -- multi-set difference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"iiii\"\n"
     ]
    }
   ],
   "source": [
    "\"mississippi\"^\"spm\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Count, reshape, take, replicate `#`\n",
    "\n",
    "Monadic `#` is _count_; it returns the cardinality of the right argument. If the argument is a vector, it returns the number of elements in the vector. If the argument is an atom, it returns 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "1\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#\"hello, world\"\n",
    "#`sym\n",
    "#42\n",
    "#,33"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the dyadic version, we have several options, depending on the type of the arguments. If the left argument is an integer vector or an integer atom, we have _reshape_: it takes whatever is to the right, and squeezes that into the shape defined by the left argument, either dropping or repeating data as required [[try it](https://ngn.bitbucket.io/k#eJyNkFEOgjAQRP85xST8YIIYqIhew3iBShbaIK1pN4bjWxCNMZC4f7uZeTu7ZZxjpXY4k1fyTmBFkGx75GALiRuZlhVKPKhm65C8BmS0aTeRgIiPENgHeYFTkFU4LCFn96TNsgzENbSZNohBoJfs9BCVC7Aq9MUvzulW8RsaKJ+UiVfW8Zxuu877D5eiceEVo+Qq6y7kS0eUWPzgRXYUdmjjWZqaPGzzffpkfAIN72gn)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "tags": [
     "no-link"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1 1 1\n"
     ]
    }
   ],
   "source": [
    "5#1                        / Reshape the atom 1 to a length 5 vector (lengthening)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "tags": [
     "no-link"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8 3 4\n",
      " 1 2 9\n",
      " 5 7 6)\n"
     ]
    }
   ],
   "source": [
    "3 3#8 3 4 1 2 9 5 7 6      / Reshape the vector 8 3 4... etc into a 3x3 matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "tags": [
     "no-link"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 3 4 1 2\n"
     ]
    }
   ],
   "source": [
    "5#8 3 4 1 2 9 5 7 6 7 4 2  / Reshape the right vector to length 5 (shortening)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With a negative left we take from the end, rather than from the beginning:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "tags": [
     "no-link"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 6 7 4 2\n"
     ]
    }
   ],
   "source": [
    "-5#8 3 4 1 2 9 5 7 6 7 4 2 / Reshape the right vector to length 5, from the back"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The right can be nested, too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "tags": [
     "no-link"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1 2 3\n",
      " 1 2 3\n",
      " 1 2 3\n",
      " 1 2 3\n",
      " 1 2 3)\n"
     ]
    }
   ],
   "source": [
    "5#,1 2 3                   / Take 5 instances of the vector 1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the right argument is a dict, and the left argument is a vector where the elements are the same type as the dict's keys, AND that type is either symbol or character, it becomes _take_, essentially picking key-value pairs from the dict, filling with nulls if necessary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`bob`eric`sam!56 0N 99\n"
     ]
    }
   ],
   "source": [
    "`bob`eric`sam#`eve`frank`rita`bob`sue`sam!32 34 52 56 83 99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the left argument is a _function_ we have _filter/replicate_. The function is assumed to return an integer vector of the same length as the right argument vector. This means that we can select using a Boolean vector,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"hloo!\"\n"
     ]
    }
   ],
   "source": [
    "{1 0 0 1 1 0 1 0 1}#\"hellobob!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or, indeed, _replicate_ elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"hhhhhoooooooooo!!!!!\"\n"
     ]
    }
   ],
   "source": [
    "{5 0 0 0 5 0 5 0 5}#\"hellobob!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drop, cut, floor etc etc etc `_`\n",
    "\n",
    "The `_` verb is overly overloaded. It can be one of _drop, cut, floor, downcase, delete, filter-out_. Monadically, it's either _floor_ or _downcase_, depending on the type of the argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43\n",
      "\"hello, world!\"\n"
     ]
    }
   ],
   "source": [
    "_43.76             / floor\n",
    "_\"Hello, World!\"   / downcase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have an integer atom to the left, and a vector to the right, we have _drop_: it truncates the vector by the specified number of items, either at the front, for a positive number, or at the back, for a negative number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"lo world!\"\n",
      "\"hello wor\"\n"
     ]
    }
   ],
   "source": [
    "3_\"hello world!\"\n",
    "-3_\"hello world!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, to spice things up a bit, if we have a vector to the left, and an integer to the _right_, we have _delete_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"helloworld!\"\n"
     ]
    }
   ],
   "source": [
    "\"hello world!\"_5   / delete element at position 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But wait! There's more. An integer vector to the left and a vector to the right, you ask? Now we're cutting. The cut vector defines the start of partitions if you like. Let's say we want to break a string on spaces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(,\"a\"\n",
      " \" string\"\n",
      " \" with\"\n",
      " \" several\"\n",
      " \" spaces\")\n"
     ]
    }
   ],
   "source": [
    "s:\"a string with several spaces\"\n",
    "(0,&\" \"=s)_s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and -- finally -- with a _function_ to the left we have _filter-out_ -- remove elements for which the left function returns true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 5 7 9 11 13 15 17 19\n"
     ]
    }
   ],
   "source": [
    "{0=2!x}_!20        / filter out all even numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String, pad, cast, int  `$`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Monadic `$` is _string_. It takes an arbitrary k-expression and turns it into a vector of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(\"12\"\n",
      " (,\"a\";,\"b\")\n",
      " \"cd\"\n",
      " ,\"+\")\n"
     ]
    }
   ],
   "source": [
    "$(12;\"ab\";`cd;+)  / a vector containing a number, a string, a symbol and a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dyadically, with an integer atom to the left and a character vector to the right, we get _pad_. It pads a string with spaces, either at the beginning or the end, depending on the sign of the left argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"baloo          \"\n",
      "\"          baloo\"\n"
     ]
    }
   ],
   "source": [
    "15$\"baloo\"    / pad end of string with spaces to make up the length 15\n",
    "-15$\"baloo\"   / pad beginning of string with spaces to make up the length 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With a magic symbol to the left, we get _cast_, which lets us convert between various k types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"abc\"\n",
      "-1 2\n",
      "`sym\n",
      "-12\n"
     ]
    }
   ],
   "source": [
    "`c$97 98 99   / convert integers to the corresponding ascii-characters\n",
    "`i$-1.2 2.3   / floats to int\n",
    "`$\"sym\"       / string to sym\n",
    "`I$\"-12\"      / string to int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unique, find, roll, deal `?`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Monadic `?` is _unique_, removing duplicates from a vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"misp\"\n"
     ]
    }
   ],
   "source": [
    "?\"missisippi\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the dyadic case, if the left argument is a vector, we're looking at _find_, which locates the first index of occurrence of the right in the left argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 1 4\n"
     ]
    }
   ],
   "source": [
    "9 6 3 6 5 3 5?3 6 5     / where can I find 3, 6 and 5 first?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Should an element on the right not be present in the left, we get nulls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 0N 4\n"
     ]
    }
   ],
   "source": [
    "9 6 3 6 5 3 5?3 2 5     / note: no 2 on the left!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the left and right arguments are both integer scalars we get either _roll_ or _deal_. _Roll_ is the roll of a set of dice; random numbers in the range specified by the right argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32 39 13\n"
     ]
    }
   ],
   "source": [
    "3?100                   / roll: 3 random integers less than 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we roll on a zero range, we get \"minus infinity\", or at least a large negative integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ",-1617955233203611231\n"
     ]
    }
   ],
   "source": [
    "1?0                     / -inf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the left argument is _negative_, we get _deal_. _Deal_ returns random elements from a specified range, but without replacement, like dealing cards from a deck. If you _deal_, the numbers you get are guaranteed to be unique:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78 28 90 52 33 37 21 35 10 85 38 77 43 19 81 27 73 34 92 59\n"
     ]
    }
   ],
   "source": [
    "-20?100                 / deal: 20 unique random numbers less than 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split, join, encode, decode `\\/`\n",
    "\n",
    "The back and forward slashes, `\\` and `/`, are mostly used as adverbs, but with certain argument types they can also function as verbs. With a character vector (or atom) left argument and a character vector to the right, `\\` becomes the very handy _split_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(,\"a\"\n",
      " \"string\"\n",
      " \"with\"\n",
      " \"embedded\"\n",
      " \"spaces\")\n",
      "(\"a string \"\n",
      " \" embedded spaces\")\n"
     ]
    }
   ],
   "source": [
    "\" \"\\\"a string with embedded spaces\"\n",
    "\"with\"\\\"a string with embedded spaces\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The forward slash, `/`, with a character vector or atom left, and a nested character vector to the right does the reverse; the equally handy _join_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"hello world\"\n"
     ]
    }
   ],
   "source": [
    "\" \"/(\"hello\";\"world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you pass integers to `\\` and `/` you get mixed radix _encode/decode_ (APL's `⊤⊥`). These are real power tools you don't get in many non-Iversonian languages ([Mathematica](https://reference.wolfram.com/language/ref/MixedRadix.html) is one exception). You use _encode_ and _decode_ to convert between different basis systems, with the canonical example working out how many days, hours, minutes and seconds are made up by a bunch of seconds.\n",
    "\n",
    "For example, how many days, hours, seconds is 10000 seconds?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 46 40\n"
     ]
    }
   ],
   "source": [
    "24 60 60\\10000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and, in reverse, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    }
   ],
   "source": [
    "24 60 60/2 46 40"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Borrowing the example given in the Mathematica docs, a Roman legion was made of 10 `cohorts`, a cohort of 6 `centuries`, a century of 10 `contuberniae`, and a contubernia of 8 soldiers. Given 16,894 soldiers, how are they organised?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`legion`cohort`century`contubernia`soldier!3 5 1 1 6\n"
     ]
    }
   ],
   "source": [
    "units:`legion`cohort`century`contubernia`soldier\n",
    "bases:10 10 6 10 8\n",
    "units!bases\\16894"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A final note on this: in ngn/k, this behaviour is different from APL (and indeed from other [ks](https://kparc.io/kc/#12%5C1%202%203%204%205%2012%205%204%203%202%201)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0 0 0 0 0 1 0 0 0 0 0\n",
      " 1 2 3 4 5 0 5 4 3 2 1)\n"
     ]
    }
   ],
   "source": [
    "12\\1 2 3 4 5 12 5 4 3 2 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In APL we get:\n",
    "```apl\n",
    "12⊤1 2 3 4 5 12 5 4 3 2 1\n",
    "\n",
    "1 2 3 4 5 0 5 4 3 2 1\n",
    "```\n",
    "\n",
    "To get ngn/k's behaviour in APL, we'd need to say\n",
    "```apl\n",
    "12 12⊤1 2 3 4 5 12 5 4 3 2 1\n",
    "\n",
    "0 0 0 0 0 1 0 0 0 0 0\n",
    "1 2 3 4 5 0 5 4 3 2 1\n",
    "```\n",
    "In other words, ngn/k will extend the left side to sufficiently represent every element on the right. In APL, you decide the shape of the result. oK doesn't implement encode/decode, but Shakti-k seems to follow the APL approach.\n",
    "\n",
    "Note that this is essentially just doing modulo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 0 5 4 3 2 1\n"
     ]
    }
   ],
   "source": [
    "*(,12)\\1 2 3 4 5 12 5 4 3 2 1   / mod 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another thing that encode/decode is handy for is to convert to and from binary, for example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 0 1 1 0\n",
      "54\n"
     ]
    }
   ],
   "source": [
    "2\\54\n",
    "2/1 1 0 1 1 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Call, index `@[ ].`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've mentioned elsewhere that one of k's many strengths is the fact that, syntactically, indexing is equivalent to function application. It's good to figure this out early.\n",
    "\n",
    "If you're familiar with a c-like language, you can rightly expect that `m[i]` means \"get the _i_th element of `m`\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0 1 2\n",
      " 3 4 5\n",
      " 6 7 8)\n",
      "3 4 5\n"
     ]
    }
   ],
   "source": [
    ":m:3 3#!9    \n",
    "m[1]         / pick row 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In k, this is syntactically equivalent to calling a function with one argument,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "m:{x+5}\n",
    "m[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and (this being k) the `@` form does exactly the same, only with one character fewer keystrokes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "m:{x+5}\n",
    "m@1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We covered indexing and indexing at depth in detail in the chapter on vectors, but here's a quick recap:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3 4 5\n",
      " 0 1 2\n",
      " 6 7 8)\n",
      "3\n",
      "3\n",
      "(3 4 5\n",
      " 0 1 2\n",
      " 6 7 8)\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "m:3 3#!9\n",
    "m[1 0 2]   / pick rows 1, 0 and 2\n",
    "m[1][0]    / pick row 1 - a vector - and from this, pick element 0\n",
    "m[1;0]     / indexing at depth; can also be used for assignment\n",
    "m@1 0 2    / equivalent to m[1 0 2]\n",
    "(m@1)@0    / equivalent to m[1][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also call a function with `.`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99\n",
      "99\n"
     ]
    }
   ],
   "source": [
    "{x+y}[23;76]  / call a function with two arguments\n",
    "{x+y}.23 76   / call a function with two arguments, taken as a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This, for example, lets us call a function over a list of arguments using the _each_ adverb, `'`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99 88 130\n"
     ]
    }
   ],
   "source": [
    "{x+y}.'(23 76;23 65;76 54)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The rest\n",
    "\n",
    "There are a few more, chiefly so-called \"special forms\", and some I/O stuff. We'll cover those separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ngn/k",
   "language": "ngnk",
   "name": "ngnk"
  },
  "language_info": {
   "file_extension": ".k",
   "mimetype": "text/ngnk",
   "name": "ngnk"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}