Metaprogramming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metaprogramming\n",
    "\n",
    "A \"meta\" program is a program that manipulates programs.\n",
    "\n",
    "Most common use refers to a program that *generates* another program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the last class we saw how Julia can generate specialized code for you.\n",
    "\n",
    "Sometimes that's not enough, and you need to write a program to explicitly generate the code needed for a specialized problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia allows us to talk in a \"meta\" way (\"one level up\"), about Julia code,  that is to \"treat code as data\" and manipulate it as just another object in Julia. (This is very similar to Lisp.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metaprogramming with text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"y + z + 7 + 1.4142135623730951\""
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = \"y + z\"\n",
    "y = 7\n",
    "\"$x + $y + $(sqrt(2))\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"2y + z\""
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"2$x\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 7\n",
    "y = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Symbols and Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the most basic objects in this approach are unevaluated *symbols*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":a"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ":a  # \"the symbol a\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":foobar"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ":foobar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Symbol"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(:a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`:a` refers to the symbol `a`. We can evaluate it with the `eval` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: a not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: a not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      " [2] eval at ./boot.jl:319 [inlined]",
      " [3] eval(::Symbol) at ./client.jl:389",
      " [4] top-level scope at In[8]:1"
     ]
    }
   ],
   "source": [
    "eval(:a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`a` must be defined for this to work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval(:a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `eval` function takes an expression and evaluates it, that is, *generates the corresponding code*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operators and function names are also symbols:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(:+, :sin)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ":+, :sin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Symbol"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(:+)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "+ (generic function with 163 methods)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Symbols may be combined into *expressions*, which are the basic objects that represent pieces of Julia code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(a + b)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex = :(a + b)  # the expression 'a + b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Expr"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 7\n",
    "eval(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An expression is just a Julia object, so we can introspect (find out information about it):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Complex{Int64}\n",
      "  re: Int64 3\n",
      "  im: Int64 4\n"
     ]
    }
   ],
   "source": [
    "dump(3+4im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol call\n",
      "  args: Array{Any}((3,))\n",
      "    1: Symbol +\n",
      "    2: Symbol a\n",
      "    3: Symbol b\n"
     ]
    }
   ],
   "source": [
    "dump(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol call\n",
      "  args: Array{Any}((3,))\n",
      "    1: Symbol +\n",
      "    2: Symbol a\n",
      "    3: Symbol b\n"
     ]
    }
   ],
   "source": [
    "dump(:(+(a,b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol call\n",
      "  args: Array{Any}((3,))\n",
      "    1: Symbol foo\n",
      "    2: Symbol bar\n",
      "    3: Symbol baz\n"
     ]
    }
   ],
   "source": [
    "dump(:(foo(bar, baz)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol =\n",
      "  args: Array{Any}((2,))\n",
      "    1: Symbol x\n",
      "    2: Int64 3\n"
     ]
    }
   ],
   "source": [
    "dump(:(x = 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex. # ex.<TAB>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":call"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex.head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Any,1}:\n",
       " :+\n",
       " :a\n",
       " :b"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex.args"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The job of Julia's parser is to convert a sequence of characters into these `Expr` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(a + b)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Meta.parse(\"a + b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More complicated expressions are represented as \"abstract syntax trees\" (ASTs), consisting of expressions nested inside expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(sin(3a + 2 * b ^ 2))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex = :( sin(3a + 2b^2) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol call\n",
      "  args: Array{Any}((2,))\n",
      "    1: Symbol sin\n",
      "    2: Expr\n",
      "      head: Symbol call\n",
      "      args: Array{Any}((3,))\n",
      "        1: Symbol +\n",
      "        2: Expr\n",
      "          head: Symbol call\n",
      "          args: Array{Any}((3,))\n",
      "            1: Symbol *\n",
      "            2: Int64 3\n",
      "            3: Symbol a\n",
      "        3: Expr\n",
      "          head: Symbol call\n",
      "          args: Array{Any}((3,))\n",
      "            1: Symbol *\n",
      "            2: Int64 2\n",
      "            3: Expr\n",
      "              head: Symbol call\n",
      "              args: Array{Any}((3,))\n",
      "                1: Symbol ^\n",
      "                2: Symbol b\n",
      "                3: Int64 2\n"
     ]
    }
   ],
   "source": [
    "dump(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Any,1}:\n",
       " :sin             \n",
       " :(3a + 2 * b ^ 2)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex.args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Expr"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(ex.args[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Any,1}:\n",
       " :+          \n",
       " :(3a)       \n",
       " :(2 * b ^ 2)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex.args[2].args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":cos"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex.args[1] = :cos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(cos(3a + 2 * b ^ 2))"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    #= In[34]:2 =#\n",
       "    println(\"Hello\")\n",
       "    #= In[34]:3 =#\n",
       "    3 + 4\n",
       "end"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blk = quote\n",
    "    println(\"Hello\")\n",
    "    3 + 4\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval(blk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol block\n",
      "  args: Array{Any}((4,))\n",
      "    1: LineNumberNode\n",
      "      line: Int64 2\n",
      "      file: Symbol In[34]\n",
      "    2: Expr\n",
      "      head: Symbol call\n",
      "      args: Array{Any}((2,))\n",
      "        1: Symbol println\n",
      "        2: String \"Hello\"\n",
      "    3: LineNumberNode\n",
      "      line: Int64 3\n",
      "      file: Symbol In[34]\n",
      "    4: Expr\n",
      "      head: Symbol call\n",
      "      args: Array{Any}((3,))\n",
      "        1: Symbol +\n",
      "        2: Int64 3\n",
      "        3: Int64 4\n"
     ]
    }
   ],
   "source": [
    "dump(blk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Array{Any,1}:\n",
       " :(#= In[34]:2 =#)  \n",
       " :(println(\"Hello\"))\n",
       " :(#= In[34]:3 =#)  \n",
       " :(3 + 4)           \n",
       " :(println(\"AFTER\"))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "push!(blk.args, :(println(\"AFTER\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    #= In[34]:2 =#\n",
       "    println(\"Hello\")\n",
       "    #= In[34]:3 =#\n",
       "    3 + 4\n",
       "    println(\"AFTER\")\n",
       "end"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "AFTER\n"
     ]
    }
   ],
   "source": [
    "eval(blk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6-element Array{Any,1}:\n",
       " :(println(\"BEFORE\"))\n",
       " :(#= In[34]:2 =#)   \n",
       " :(println(\"Hello\")) \n",
       " :(#= In[34]:3 =#)   \n",
       " :(3 + 4)            \n",
       " :(println(\"AFTER\")) "
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pushfirst!(blk.args, :(println(\"BEFORE\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    println(\"BEFORE\")\n",
       "    #= In[34]:2 =#\n",
       "    println(\"Hello\")\n",
       "    #= In[34]:3 =#\n",
       "    3 + 4\n",
       "    println(\"AFTER\")\n",
       "end"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BEFORE\n",
      "Hello\n",
      "AFTER\n"
     ]
    }
   ],
   "source": [
    "eval(blk)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expressions can be arbitrary Julia code that when evaluated will have side effects. For longer blocks of code, `quote...end` may be used instead of `:( ... )`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex2 = \n",
    "quote\n",
    "    y = 3\n",
    "    z = sin(y+1)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(ex2)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(ex2)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The full form of the abstract syntax tree in a style similar to a Lisp s-expression can be obtained using functions from the `Meta` module in `Base`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(:block,\n",
      "  (:call, :println, \"BEFORE\"),\n",
      "  :(#= In[34]:2 =#),\n",
      "  (:call, :println, \"Hello\"),\n",
      "  :(#= In[34]:3 =#),\n",
      "  (:call, :+, 3, 4),\n",
      "  (:call, :println, \"AFTER\")\n",
      ")"
     ]
    }
   ],
   "source": [
    "Meta.show_sexpr(blk)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way of seeing the structure is with `dump`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dump(ex2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interpolation\n",
    "\n",
    "Values can be *interpolated* into expressions with `$`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(2 * (x + y))"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = :(x + y)\n",
    ":(2 * $a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(x + 2)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ":(x + $x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":y"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = :y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(x + y)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ":(x + $x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why not strings?\n",
    "\n",
    "*Abstract* syntax vs. *concrete* syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"x + y\""
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"x + y\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"z\""
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = \"z\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"x + y * z\""
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = \"$a * z\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even worse, what if `z == \")\"`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `Expr` objects, every expression is well-formed and each slot has its abstract meaning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splat interpolation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Symbol,1}:\n",
       " :a\n",
       " :b\n",
       " :c"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars = [:a, :b, :c]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(1 - f(0, a, b, c))"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex = :(1 - f(0, $(vars...)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol call\n",
      "  args: Array{Any}((3,))\n",
      "    1: Symbol -\n",
      "    2: Int64 1\n",
      "    3: Expr\n",
      "      head: Symbol call\n",
      "      args: Array{Any}((5,))\n",
      "        1: Symbol f\n",
      "        2: Int64 0\n",
      "        3: Symbol a\n",
      "        4: Symbol b\n",
      "        5: Symbol c\n"
     ]
    }
   ],
   "source": [
    "dump(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `@eval` for interpolating on the fly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will sometimes see `@eval expr`, which is shorthand for:\n",
    "\n",
    "```\n",
    "eval(quote\n",
    "         expr\n",
    "     end)\n",
    "```\n",
    "\n",
    "allowing items to be interpolated immediately before executing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Array{Symbol,1}:\n",
       " :func1 \n",
       " :func2 \n",
       " :func3 \n",
       " :func4 \n",
       " :func5 \n",
       " :func6 \n",
       " :func7 \n",
       " :func8 \n",
       " :func9 \n",
       " :func10"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fnames = [ Symbol(\"func$i\") for i=1:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "func2 (generic function with 1 method)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i = 1:length(fnames)\n",
    "    @eval ($(fnames[i]))(x) = x + $i\n",
    "    \n",
    "    #equivalently:\n",
    "    eval(quote\n",
    "          $(fnames[i])(x) = x + $i\n",
    "         end)\n",
    "end\n",
    "\n",
    "# equivalent to:\n",
    "func1(x) = x + 1\n",
    "func2(x) = x + 2\n",
    "# etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func1(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func2(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func10(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Macros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the ability to think of code in terms of a data structure in the Julia language, we can now *manipulate* those data structures, allowing us to *create Julia code from within Julia*.\n",
    "\n",
    "*Macros* provide a particular use pattern of metaprogramming: replacing one expression with another, in-place, right after parsing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [Julia manual](http://julia.readthedocs.org/en/latest/manual/metaprogramming/) puts it like this: \n",
    "\n",
    "> macros map a tuple of argument *expressions* to a returned\n",
    "> *expression*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Macros are useful in several cases:\n",
    "\n",
    "- to provide a specific notation different than what can normally be written in the language\n",
    "    - e.g. https://github.com/JuliaOpt/JuMP.jl/blob/release-0.18/examples/sudoku.jl#L44\n",
    "- to rearrange or delay evaluation of code\n",
    "- to eliminate boilerplate (repetitive) code\n",
    "- to automatically generate complex code that would be painful by hand\n",
    "- to unroll loops for efficiency\n",
    "- to inline code for efficiency\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol macrocall\n",
      "  args: Array{Any}((3,))\n",
      "    1: Symbol @foo\n",
      "    2: LineNumberNode\n",
      "      line: Int64 1\n",
      "      file: Symbol none\n",
      "    3: Expr\n",
      "      head: Symbol call\n",
      "      args: Array{Any}((3,))\n",
      "        1: Symbol +\n",
      "        2: Symbol x\n",
      "        3: Symbol y\n"
     ]
    }
   ],
   "source": [
    "dump(Meta.parse(\"@foo x + y\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Macros are invoked using the `@` sign, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.142367 seconds (396.66 k allocations: 20.180 MiB, 4.31% gc time)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-0.5440211108893698"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@time sin(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare to:\n",
    "```jl\n",
    "mytime(sin(10))\n",
    "```\n",
    "As an ordinary function, `mytime`, this **could not work**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    #= util.jl:154 =#\n",
       "    local #2#stats = (Base.gc_num)()\n",
       "    #= util.jl:155 =#\n",
       "    local #4#elapsedtime = (Base.time_ns)()\n",
       "    #= util.jl:156 =#\n",
       "    local #3#val = sin(10)\n",
       "    #= util.jl:157 =#\n",
       "    #4#elapsedtime = (Base.time_ns)() - #4#elapsedtime\n",
       "    #= util.jl:158 =#\n",
       "    local #5#diff = (Base.GC_Diff)((Base.gc_num)(), #2#stats)\n",
       "    #= util.jl:159 =#\n",
       "    (Base.time_print)(#4#elapsedtime, (#5#diff).allocd, (#5#diff).total_time, (Base.gc_alloc_count)(#5#diff))\n",
       "    #= util.jl:161 =#\n",
       "    (Base.println)()\n",
       "    #= util.jl:162 =#\n",
       "    #3#val\n",
       "end"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macroexpand(Main, :(@time sin(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A trivial example of defining a macro is the following, which runs whatever code it is passed two times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@twice (macro with 1 method)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macro twice(ex)\n",
    "    quote\n",
    "        $ex\n",
    "        $ex\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "@twice println(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(#= In[75]:1 =# @twice println(\"hello\"))"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex = :(@twice println(\"hello\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "eval(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol macrocall\n",
      "  args: Array{Any}((3,))\n",
      "    1: Symbol @twice\n",
      "    2: LineNumberNode\n",
      "      line: Int64 1\n",
      "      file: Symbol In[75]\n",
      "    3: Expr\n",
      "      head: Symbol call\n",
      "      args: Array{Any}((2,))\n",
      "        1: Symbol println\n",
      "        2: String \"hello\"\n"
     ]
    }
   ],
   "source": [
    "dump(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see what effect the macro actually has using `macroexpand`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    #= In[71]:3 =#\n",
       "    (Main.println)(\"hello\")\n",
       "    #= In[71]:4 =#\n",
       "    (Main.println)(\"hello\")\n",
       "end"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macroexpand(Main, :(@twice println(\"hello\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@mytime (macro with 1 method)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macro mytime(ex)\n",
    "    quote\n",
    "        t0 = time()\n",
    "        val = $(esc(ex))\n",
    "        t1 = time()\n",
    "        println(\"$(t1-t0) seconds elapsed\")\n",
    "        val\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0399909019470215 seconds elapsed\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"done\""
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@mytime (sleep(1); \"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A line break terminates macro arguments, so blocks need to be passed with `begin...end`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0011420249938965 seconds elapsed\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@mytime t0 = (sleep(1); 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    #= In[91]:3 =#\n",
       "    #43#t0 = (Main.time)()\n",
       "    #= In[91]:4 =#\n",
       "    #44#val = (t0 = begin\n",
       "                sleep(1)\n",
       "                #= In[93]:1 =#\n",
       "                7\n",
       "            end)\n",
       "    #= In[91]:5 =#\n",
       "    #45#t1 = (Main.time)()\n",
       "    #= In[91]:6 =#\n",
       "    (Main.println)(\"$(#45#t1 - #43#t0) seconds elapsed\")\n",
       "    #= In[91]:7 =#\n",
       "    #44#val\n",
       "end"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macroexpand(Main, :(@mytime t0 = (sleep(1); 7)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "**Exercise**: Define a macro `@until` that does an `until` loop.\n",
    "\n",
    "```jl\n",
    "x = 0\n",
    "@until x > 3 begin\n",
    "    global x = x+1\n",
    "end\n",
    "```\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@until (macro with 1 method)"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macro until(cond, body)\n",
    "    quote\n",
    "        $(esc(body))\n",
    "        while !$(esc(cond))\n",
    "            $(esc(body))\n",
    "        end\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@until (macro with 1 method)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macro until(cond, body)\n",
    "    quote\n",
    "        while true\n",
    "            $(esc(body))\n",
    "            if $(esc(cond))\n",
    "                break\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 0\n",
    "@until x > 3 begin\n",
    "    global x = x+1\n",
    "end\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "x = 7\n",
    "@until x > 3 begin\n",
    "    println(\"hello\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Macro Hygiene"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "macro set_x(val)\n",
    "    :(x = $val)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@set_x 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "macro set_x(val)\n",
    "    :($(esc(:x)) = $val)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@set_x 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Macros for numerical performance: Horner's method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many interesting examples of macros in `Base`. One that is accessible is Horner's method for evaluating a polynomial:\n",
    "\n",
    "$$p(x) = a_n x^n + a_{n-1} x^{n-1} + \\cdots + a_1 x^1 + a_0$$\n",
    "\n",
    "may be evaluated efficiently as\n",
    "\n",
    "$$p(x) = a_0 + x(a_1 + \\cdots x(a_{n-2} + \\cdots + x(a_{n-1} + x a_n) \\cdots ) ) $$\n",
    "with only $n$ multiplications.\n",
    "\n",
    "The obvious way to do this is with a `for` loop. But if we know the polynomial *at compile time*, this loop may be unrolled using metaprogramming. This is implemented in the `Math` module in `math.jl` in `Base`, so the name of the macro (which is not exported) is `@Base.Math.horner`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@horner (macro with 1 method)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# copied from base/math.jl\n",
    "macro horner(x, p...)\n",
    "    ex = esc(p[end])\n",
    "    for i = length(p)-1:-1:1\n",
    "        ex = :( $(esc(p[i])) + t * $ex )  # actually uses `muladd`\n",
    "    end\n",
    "    Expr(:block, :(t = $(esc(x))), ex)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is called as follows: to evaluate the polynomial $p(x) = 2 + 3x + 4x^2$ at $x=3$, we do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "182"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "@horner(x, 2, 3, 4, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see what the macro does to this call, we again use `macroexpand`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    #48#t = x\n",
       "    2 + #48#t * (3 + #48#t * (4 + #48#t * (5 + #48#t * (6 + #48#t * (7 + #48#t * (8 + #48#t * (9 + #48#t * 10)))))))\n",
       "end"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macroexpand(Main, :(@horner(x, 2, 3, 4, 5, 6, 7, 8, 9, 10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    #49#t = x\n",
       "    (Base.Math.muladd)(#49#t, (Base.Math.muladd)(#49#t, (Base.Math.muladd)(#49#t, 5, 4), 3), 2)\n",
       "end"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macroexpand(Main, :(@Base.Math.horner(x, 2, 3, 4, 5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?muladd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?fma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(x) = Base.Math.@horner(x, 1.2, 2.3, 3.4, 4.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "; Function f\n",
      "; Location: In[107]:1\n",
      "define double @julia_f_36037(double) {\n",
      "top:\n",
      "; Function muladd; {\n",
      "; Location: float.jl:404\n",
      "  %1 = fmul contract double %0, 4.500000e+00\n",
      "  %2 = fadd contract double %1, 3.400000e+00\n",
      "  %3 = fmul contract double %2, %0\n",
      "  %4 = fadd contract double %3, 2.300000e+00\n",
      "  %5 = fmul contract double %4, %0\n",
      "  %6 = fadd contract double %5, 1.200000e+00\n",
      ";}\n",
      "  ret double %6\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "@code_llvm f(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t.section\t__TEXT,__text,regular,pure_instructions\n",
      "; Function f {\n",
      "; Location: In[107]:1\n",
      "\tdecl\t%eax\n",
      "\tmovl\t$592529504, %eax        ## imm = 0x23514860\n",
      "\taddl\t%eax, (%eax)\n",
      "\taddb\t%al, (%eax)\n",
      "; Function muladd; {\n",
      "; Location: float.jl:404\n",
      "\tvmovsd\t(%eax), %xmm1           ## xmm1 = mem[0],zero\n",
      "\tdecl\t%eax\n",
      "\tmovl\t$592529512, %eax        ## imm = 0x23514868\n",
      "\taddl\t%eax, (%eax)\n",
      "\taddb\t%al, (%eax)\n",
      "\tvfmadd213sd\t(%eax), %xmm0, %xmm1\n",
      "\tdecl\t%eax\n",
      "\tmovl\t$592529520, %eax        ## imm = 0x23514870\n",
      "\taddl\t%eax, (%eax)\n",
      "\taddb\t%al, (%eax)\n",
      "\tvfmadd213sd\t(%eax), %xmm0, %xmm1\n",
      "\tdecl\t%eax\n",
      "\tmovl\t$592529528, %eax        ## imm = 0x23514878\n",
      "\taddl\t%eax, (%eax)\n",
      "\taddb\t%al, (%eax)\n",
      "\tvfmadd213sd\t(%eax), %xmm1, %xmm0\n",
      ";}\n",
      "\tretl\n",
      "\tnopl\t(%eax)\n",
      ";}\n"
     ]
    }
   ],
   "source": [
    "@code_native f(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(x) = @evalpoly(x, 1.2, 2.3, 3.4, 4.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```\n",
       "@evalpoly(z, c...)\n",
       "```\n",
       "\n",
       "Evaluate the polynomial $\\sum_k c[k] z^{k-1}$ for the coefficients `c[1]`, `c[2]`, ...; that is, the coefficients are given in ascending order by power of `z`.  This macro expands to efficient inline code that uses either Horner's method or, for complex `z`, a more efficient Goertzel-like algorithm.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> @evalpoly(3, 1, 0, 1)\n",
       "10\n",
       "\n",
       "julia> @evalpoly(2, 1, 0, 1)\n",
       "5\n",
       "\n",
       "julia> @evalpoly(2, 1, 1, 1)\n",
       "7\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  @evalpoly(z, c...)\u001b[39m\n",
       "\n",
       "  Evaluate the polynomial \u001b[35m\\sum_k c[k] z^{k-1}\u001b[39m for the coefficients \u001b[36mc[1]\u001b[39m, \u001b[36mc[2]\u001b[39m,\n",
       "  ...; that is, the coefficients are given in ascending order by power of \u001b[36mz\u001b[39m.\n",
       "  This macro expands to efficient inline code that uses either Horner's method\n",
       "  or, for complex \u001b[36mz\u001b[39m, a more efficient Goertzel-like algorithm.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> @evalpoly(3, 1, 0, 1)\u001b[39m\n",
       "\u001b[36m  10\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> @evalpoly(2, 1, 0, 1)\u001b[39m\n",
       "\u001b[36m  5\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> @evalpoly(2, 1, 1, 1)\u001b[39m\n",
       "\u001b[36m  7\u001b[39m"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?@evalpoly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "; Function f\n",
      "; Location: In[110]:1\n",
      "define double @julia_f_36122(double) {\n",
      "top:\n",
      "; Function macro expansion; {\n",
      "; Location: math.jl:150\n",
      "; Function muladd; {\n",
      "; Location: float.jl:404\n",
      "  %1 = fmul contract double %0, 4.500000e+00\n",
      "  %2 = fadd contract double %1, 3.400000e+00\n",
      "  %3 = fmul contract double %2, %0\n",
      "  %4 = fadd contract double %3, 2.300000e+00\n",
      "  %5 = fmul contract double %4, %0\n",
      "  %6 = fadd contract double %5, 1.200000e+00\n",
      ";}}\n",
      "  ret double %6\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "@code_llvm f(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "; Function f\n",
      "; Location: In[110]:1\n",
      "define void @julia_f_36126({ double, double }* noalias nocapture sret, { double, double } addrspace(11)* nocapture nonnull readonly dereferenceable(16)) {\n",
      "top:\n",
      "; Function macro expansion; {\n",
      "; Location: math.jl:150\n",
      "; Function real; {\n",
      "; Location: complex.jl:63\n",
      "; Function getproperty; {\n",
      "; Location: sysimg.jl:18\n",
      "  %2 = getelementptr inbounds { double, double }, { double, double } addrspace(11)* %1, i64 0, i32 0\n",
      ";}}\n",
      "; Function imag; {\n",
      "; Location: complex.jl:76\n",
      "; Function getproperty; {\n",
      "; Location: sysimg.jl:18\n",
      "  %3 = getelementptr inbounds { double, double }, { double, double } addrspace(11)* %1, i64 0, i32 1\n",
      ";}}\n",
      "; Function +; {\n",
      "; Location: float.jl:395\n",
      "  %4 = load double, double addrspace(11)* %2, align 8\n",
      "  %5 = fadd double %4, %4\n",
      ";}\n",
      "; Function *; {\n",
      "; Location: float.jl:399\n",
      "  %6 = load double, double addrspace(11)* %3, align 8\n",
      "  %7 = fmul double %6, %6\n",
      ";}\n",
      "; Function muladd; {\n",
      "; Location: float.jl:404\n",
      "  %8 = fmul contract double %4, %4\n",
      "  %9 = fadd contract double %8, %7\n",
      "  %10 = fmul contract double %5, 4.500000e+00\n",
      "  %11 = fadd contract double %10, 3.400000e+00\n",
      ";}\n",
      "; Function *; {\n",
      "; Location: float.jl:399\n",
      "  %12 = fmul double %9, 4.500000e+00\n",
      ";}\n",
      "; Function -; {\n",
      "; Location: float.jl:397\n",
      "  %13 = fsub double 2.300000e+00, %12\n",
      ";}\n",
      "; Function muladd; {\n",
      "; Location: float.jl:404\n",
      "  %14 = fmul contract double %5, %11\n",
      "  %15 = fadd contract double %14, %13\n",
      ";}\n",
      "; Function *; {\n",
      "; Location: float.jl:399\n",
      "  %16 = fmul double %9, %11\n",
      ";}\n",
      "; Function -; {\n",
      "; Location: float.jl:397\n",
      "  %17 = fsub double 1.200000e+00, %16\n",
      ";}\n",
      "; Function muladd; {\n",
      "; Location: complex.jl:314\n",
      "; Function muladd; {\n",
      "; Location: complex.jl:315\n",
      "; Function muladd; {\n",
      "; Location: float.jl:404\n",
      "  %18 = fmul contract double %4, %15\n",
      "  %19 = fadd contract double %17, %18\n",
      ";}\n",
      "; Function *; {\n",
      "; Location: float.jl:399\n",
      "  %20 = fmul double %6, %15\n",
      ";}}}\n",
      "  %.sroa.0.0..sroa_idx = getelementptr inbounds { double, double }, { double, double }* %0, i64 0, i32 0\n",
      "  store double %19, double* %.sroa.0.0..sroa_idx, align 8\n",
      "  %.sroa.2.0..sroa_idx1 = getelementptr inbounds { double, double }, { double, double }* %0, i64 0, i32 1\n",
      "  store double %20, double* %.sroa.2.0..sroa_idx1, align 8\n",
      "  ret void\n",
      ";}\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "@code_llvm f(0.1+0.3im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "g (generic function with 1 method)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(x) = Base.Math.@horner(x, 1.2, 2.3, 3.4, 4.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "using BenchmarkTools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1.894 ns (0 allocations: 0 bytes)\n",
      "  2.261 ns (0 allocations: 0 bytes)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-542.2 + 288.79999999999995im"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@btime f(3.0+4.0im)\n",
    "@btime g(3.0+4.0im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "horner (generic function with 1 method)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function horner(x, p)\n",
    "    y = p[end]\n",
    "    for i = length(p)-1:-1:1\n",
    "        y = p[i] + x * y\n",
    "    end\n",
    "    return y\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "horner(4, [3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@horner 4 3 4 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## `@generated` Functions\n",
    "\n",
    "Another form of metaprogramming available in Julia.\n",
    "\n",
    "Generate code based on *types* instead of the input expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@generated function nloops(a::Array{T,N}) where {T,N}\n",
    "    # inside here,\n",
    "    # - `a` refers to the type of the argument\n",
    "    # - `T` and `N` have their usual values\n",
    "    # - return an expression to compute the answer for this type\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Julia 1.0.0",
   "language": "julia",
   "name": "julia-1.0"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.0.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}