MyThinkJulia-Ch12z-MultipleDispatchIntro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiple Dispatch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we'll explore **multiple dispatch**, which is a key feature of Julia.\n",
    "\n",
    "Multiple dispatch makes software *generic* and *fast*!\n",
    "\n",
    "#### Starting with the familiar\n",
    "\n",
    "To understand multiple dispatch in Julia, let's start with what we've already seen.\n",
    "\n",
    "We can declare functions in Julia without giving Julia any information about the types of the input arguments that function will receive:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "square (generic function with 1 method)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square(x) = x^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello Hello \""
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square(\"Hello \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching ^(::Array{Int64,1}, ::Int64)\nClosest candidates are:\n  ^(!Matched::Float16, ::Integer) at math.jl:796\n  ^(!Matched::Missing, ::Integer) at missing.jl:130\n  ^(!Matched::Missing, ::Number) at missing.jl:94\n  ...",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching ^(::Array{Int64,1}, ::Int64)\nClosest candidates are:\n  ^(!Matched::Float16, ::Integer) at math.jl:796\n  ^(!Matched::Missing, ::Integer) at missing.jl:130\n  ^(!Matched::Missing, ::Number) at missing.jl:94\n  ...",
      "",
      "Stacktrace:",
      " [1] macro expansion at .\\none:0 [inlined]",
      " [2] literal_pow at .\\none:0 [inlined]",
      " [3] square(::Array{Int64,1}) at .\\In[1]:1",
      " [4] top-level scope at In[4]:1"
     ]
    }
   ],
   "source": [
    "square([1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Specifying the types of our input arguments\n",
    "\n",
    "However, we also have the *option* to tell Julia explicitly what types our input arguments are allowed to have.\n",
    "\n",
    "For example, let's write a function `f` that only takes `Number`s as inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(a::Integer, b::Integer) = \"a and b are both integers\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a and b are both integers\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching f(::Float64, ::Float64)",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching f(::Float64, ::Float64)",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[7]:1"
     ]
    }
   ],
   "source": [
    "f(1.2, 3.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we can define that method!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 2 methods)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(a::Float64, b::Float64) = \"a and b are both Float64s\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a and b are both Float64s\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1.2, 3.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Basic dispatch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 6 methods)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(a, b) = \"fallback\"\n",
    "f(a::Number, b::Number) = \"a and b are both numbers\"\n",
    "f(a::Number, b) = \"a is a number\"\n",
    "f(a, b::Number) = \"b is a number\"\n",
    "f(a::Integer, b::Integer) = \"a and b are both integers\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "6 methods for generic function <b>f</b>:<ul><li> f(a::<b>Float64</b>, b::<b>Float64</b>) in Main at In[8]:1</li> <li> f(a::<b>Integer</b>, b::<b>Integer</b>) in Main at In[10]:5</li> <li> f(a::<b>Number</b>, b::<b>Number</b>) in Main at In[10]:2</li> <li> f(a::<b>Number</b>, b) in Main at In[10]:3</li> <li> f(a, b::<b>Number</b>) in Main at In[10]:4</li> <li> f(a, b) in Main at In[10]:1</li> </ul>"
      ],
      "text/plain": [
       "# 6 methods for generic function \"f\":\n",
       "[1] f(a::Float64, b::Float64) in Main at In[8]:1\n",
       "[2] f(a::Integer, b::Integer) in Main at In[10]:5\n",
       "[3] f(a::Number, b::Number) in Main at In[10]:2\n",
       "[4] f(a::Number, b) in Main at In[10]:3\n",
       "[5] f(a, b::Number) in Main at In[10]:4\n",
       "[6] f(a, b) in Main at In[10]:1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a and b are both numbers\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1.5, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a is a number\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1, \"bar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a and b are both integers\""
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"fallback\""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(\"foo\", [1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching f(::Int64, ::Int64, ::Int64)\nClosest candidates are:\n  f(::Integer, ::Integer) at In[10]:5\n  f(::Number, ::Number) at In[10]:2\n  f(::Number, ::Any) at In[10]:3\n  ...",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching f(::Int64, ::Int64, ::Int64)\nClosest candidates are:\n  f(::Integer, ::Integer) at In[10]:5\n  f(::Number, ::Number) at In[10]:2\n  f(::Number, ::Any) at In[10]:3\n  ...",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[16]:1"
     ]
    }
   ],
   "source": [
    "f(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ambiguities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "g (generic function with 2 methods)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(a::Int, b::Number) = 1\n",
    "g(a::Number, b::Int) = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(1, 2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(1.5, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: g(::Int64, ::Int64) is ambiguous. Candidates:\n  g(a::Number, b::Int64) in Main at In[17]:2\n  g(a::Int64, b::Number) in Main at In[17]:1\nPossible fix, define\n  g(::Int64, ::Int64)",
     "output_type": "error",
     "traceback": [
      "MethodError: g(::Int64, ::Int64) is ambiguous. Candidates:\n  g(a::Number, b::Int64) in Main at In[17]:2\n  g(a::Int64, b::Number) in Main at In[17]:1\nPossible fix, define\n  g(::Int64, ::Int64)",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[20]:1"
     ]
    }
   ],
   "source": [
    "g(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "g (generic function with 3 methods)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(x::Int, y::Int) = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### \"Diagonal\" dispatch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 7 methods)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(a::T, b::T) where {T<:Number} = \"a and b are both $(T)s\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "7 methods for generic function <b>f</b>:<ul><li> f(a::<b>Float64</b>, b::<b>Float64</b>) in Main at In[8]:1</li> <li> f(a::<b>Integer</b>, b::<b>Integer</b>) in Main at In[10]:5</li> <li> f(a::<b>T</b>, b::<b>T</b>)<i> where T<:Number</i> in Main at In[23]:1</li> <li> f(a::<b>Number</b>, b::<b>Number</b>) in Main at In[10]:2</li> <li> f(a::<b>Number</b>, b) in Main at In[10]:3</li> <li> f(a, b::<b>Number</b>) in Main at In[10]:4</li> <li> f(a, b) in Main at In[10]:1</li> </ul>"
      ],
      "text/plain": [
       "# 7 methods for generic function \"f\":\n",
       "[1] f(a::Float64, b::Float64) in Main at In[8]:1\n",
       "[2] f(a::Integer, b::Integer) in Main at In[10]:5\n",
       "[3] f(a::T, b::T) where T<:Number in Main at In[23]:1\n",
       "[4] f(a::Number, b::Number) in Main at In[10]:2\n",
       "[5] f(a::Number, b) in Main at In[10]:3\n",
       "[6] f(a, b::Number) in Main at In[10]:4\n",
       "[7] f(a, b) in Main at In[10]:1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a and b are both BigFloats\""
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(big(1.5), big(2.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a and b are both integers\""
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(big(1), big(2)) # <== integer rule is more specific"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 8 methods)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(a::T, b::T) where {T<:Integer} = \"both are $T integers\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "8 methods for generic function <b>f</b>:<ul><li> f(a::<b>Float64</b>, b::<b>Float64</b>) in Main at In[8]:1</li> <li> f(a::<b>T</b>, b::<b>T</b>)<i> where T<:Integer</i> in Main at In[27]:1</li> <li> f(a::<b>Integer</b>, b::<b>Integer</b>) in Main at In[10]:5</li> <li> f(a::<b>T</b>, b::<b>T</b>)<i> where T<:Number</i> in Main at In[23]:1</li> <li> f(a::<b>Number</b>, b::<b>Number</b>) in Main at In[10]:2</li> <li> f(a::<b>Number</b>, b) in Main at In[10]:3</li> <li> f(a, b::<b>Number</b>) in Main at In[10]:4</li> <li> f(a, b) in Main at In[10]:1</li> </ul>"
      ],
      "text/plain": [
       "# 8 methods for generic function \"f\":\n",
       "[1] f(a::Float64, b::Float64) in Main at In[8]:1\n",
       "[2] f(a::T, b::T) where T<:Integer in Main at In[27]:1\n",
       "[3] f(a::Integer, b::Integer) in Main at In[10]:5\n",
       "[4] f(a::T, b::T) where T<:Number in Main at In[23]:1\n",
       "[5] f(a::Number, b::Number) in Main at In[10]:2\n",
       "[6] f(a::Number, b) in Main at In[10]:3\n",
       "[7] f(a, b::Number) in Main at In[10]:4\n",
       "[8] f(a, b) in Main at In[10]:1"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"both are BigInt integers\""
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(big(1), big(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"fallback\""
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(\"foo\", \"bar\") # <== still doesn't apply to non-numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Varargs methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 10 methods)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(args::Number...) = \"$(length(args))-ary heterogeneous call\"\n",
    "f(args::T...) where {T<:Number} = \"$(length(args))-ary homogeneous call\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"1-ary homogeneous call\""
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"3-ary homogeneous call\""
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"3-ary heterogeneous call\""
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1, 1.5, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"0-ary homogeneous call\""
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"both are Int64 integers\""
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1, 2) # <== previous 2-arg method is more specific"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching f(::String)\nClosest candidates are:\n  f(::Any, !Matched::Number) at In[10]:4\n  f(::Any, !Matched::Any) at In[10]:1\n  f(!Matched::Float64, !Matched::Float64) at In[8]:1\n  ...",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching f(::String)\nClosest candidates are:\n  f(::Any, !Matched::Number) at In[10]:4\n  f(::Any, !Matched::Any) at In[10]:1\n  f(!Matched::Float64, !Matched::Float64) at In[8]:1\n  ...",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[37]:1"
     ]
    }
   ],
   "source": [
    "f(\"foo\") # <== still doesn't apply to non-numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"3-ary homogeneous call\""
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# \"splat\" (more below)\n",
    "f([1, 2, 3]...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optional Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h (generic function with 2 methods)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h(x, y = 0) = 2x + 3y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2 methods for generic function <b>h</b>:<ul><li> h(x) in Main at In[39]:1</li> <li> h(x, y) in Main at In[39]:1</li> </ul>"
      ],
      "text/plain": [
       "# 2 methods for generic function \"h\":\n",
       "[1] h(x) in Main at In[39]:1\n",
       "[2] h(x, y) in Main at In[39]:1"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shorthand for this:\n",
    "```\n",
    "h(x, y) = 2x + 3y\n",
    "h(x) = h(x, 0)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "k (generic function with 2 methods)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k(x, y = 0; opt::Bool = false) = opt ? 2x+y : x+2y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k(2, opt=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k(2, 3, opt=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "foo (generic function with 1 method)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo(x, y; req::Bool) = req ? 2x+y : x+2y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefKeywordError",
     "evalue": "UndefKeywordError: keyword argument req not assigned",
     "output_type": "error",
     "traceback": [
      "UndefKeywordError: keyword argument req not assigned",
      "",
      "Stacktrace:",
      " [1] foo(::Int64, ::Int64) at .\\In[46]:1",
      " [2] top-level scope at In[47]:1"
     ]
    }
   ],
   "source": [
    "foo(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2 methods for generic function <b>k</b>:<ul><li> k(x) in Main at In[41]:1</li> <li> k(x, y; <i>opt</i>) in Main at In[41]:1</li> </ul>"
      ],
      "text/plain": [
       "# 2 methods for generic function \"k\":\n",
       "[1] k(x) in Main at In[41]:1\n",
       "[2] k(x, y; opt) in Main at In[41]:1"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k(2, opt=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword arguments: slurp and splat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "allkw (generic function with 1 method)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function allkw(; kw...)\n",
    "    @show keys(kw)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "keys(kw) = (:a, :b)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(:a, :b)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allkw(a=1,b=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like iterators can be splatted as positional arguments, dict-like collections and named tuples can be splatted as keyword arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rect (generic function with 1 method)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function rect(;width=1,height=1,fill=\"#\")\n",
    "    for i in 1:height\n",
    "        println(fill^width)\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(width = 8, height = 3, fill = 'A')"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "params = (width=8,height=3,fill='A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AAAAAAAA\n",
      "AAAAAAAA\n",
      "AAAAAAAA\n"
     ]
    }
   ],
   "source": [
    "rect(; params...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "\n",
    "#### Exercise 1\n",
    "\n",
    "Write a function that repeats a string an integer number of times which takes the arguments in either order.\n",
    "\n",
    "#### Exercise 2a\n",
    "\n",
    "Write a function `F` that returns the tuple `(x, y, k)` where:\n",
    "- `x` is the first positional argument and is mandatory\n",
    "- `y` is the second positional argument and is optional\n",
    "- `k` is an optional keyword argument\n",
    "\n",
    "The optional arguments should have the following defaults:\n",
    "- `y` defaults to `2x`\n",
    "- `k` defaults to `2y`\n",
    "\n",
    "#### Exercise 2b\n",
    "\n",
    "Write a function `G` just like `F` but with differet defaults:\n",
    "- `k` defaults to `2x`\n",
    "- `y` defaults to `2k`"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Julia 1.2.0",
   "language": "julia",
   "name": "julia-1.2"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}