MyThinkJulia-Ch17-1-Multiple Dispatch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch 17: Multiple Dispatch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this chapter we will discuss the use of type declarations in Julia and introduce methods, which are ways to implement different behavior for a function depending on the types of its arguments. This is called multiple dispatch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Julia's Type System"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia programs manipulate *values*.  Every value has two parts: a *type* part and a *data* part. The type part answers the question \"what kind of thing is this?\", and the data part distinguishes one thing of a certain kind from every other thing of that kind."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DataType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case the type is `Int64` and the data part is the bits `...0011`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Julia types are also values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataType"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(Int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataType"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(DataType)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, the identity `typeof(typeof(x)) === DataType` holds for all values in Julia. `DataType` is the backbone of the entire system. It does many jobs, which can be identified by looking inside a `DataType` object:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DataType Job 1: A symbolic description"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This consists of a name (which is mostly a string), and a vector of sub-components:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Complex{Int64}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp = typeof(1+2im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Complex"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "svec(Int64)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DataType Job 2: Describe the representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "svec(Int64, Int64)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "svec(:re, :im)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.name.names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.mutable   # whether this was declared with `type` (vs. `immutable`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.ninitialized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ptr{Nothing} @0x000000000e207a30"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.layout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ptr{T}: A memory address referring to data of type `T`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ptr{Nothing}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(T_comp.layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mN\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mh\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mg\u001b[22m \u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mh\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mg\u001b[22m is\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mh\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mg\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "Nothing\n",
       "\\end{verbatim}\n",
       "A type with no fields that is the type of \\href{@ref}{\\texttt{nothing}}.\n",
       "\n"
      ],
      "text/markdown": [
       "```\n",
       "Nothing\n",
       "```\n",
       "\n",
       "A type with no fields that is the type of [`nothing`](@ref).\n"
      ],
      "text/plain": [
       "\u001b[36m  Nothing\u001b[39m\n",
       "\n",
       "  A type with no fields that is the type of \u001b[36mnothing\u001b[39m."
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?Nothing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DataType Job 3: A nominal hierarchy of types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DataTypes form a tree of declared type relationships:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Number"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.super"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Any"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_comp.super.super  # `Any` is the built-in top of the hierarchy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's explore this hierarchy (super- vs sub-) of types a little further.  \n",
    "\n",
    "A supertype and a subtype has 'IS-A' relationship, similar to the relatonship between the parent class and its children classes in Python and Java.\n",
    "\n",
    "Every type has a super type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Signed"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Int64.super"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Integer"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Signed.super"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Real"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Integer.super"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Number"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Real.super"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Any"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Number.super"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Any,1}:\n",
       " Complex\n",
       " Real   "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subtypes(Number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Abstract vs. Concrete Types:\n",
    "\n",
    "Concrete types are those that can create instances.  Like `Int64` or `Float64`.\n",
    "\n",
    "A type `T` is concrete if there could be some value `x` such that `typeof(x) === T`. This is also sometimes called a \"leaf type\".\n",
    "\n",
    "We often need a way to group related concrete types. In Julia this is done by defining an abstract type that serves as a parent\n",
    "or super type. This is called **subtyping**.\n",
    "\n",
    "So, in quick summary, *Abstract* types can have declared subtypes, while *concrete* types can have instances.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(true, true, true, true, false)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Number.abstract, Real.abstract, Integer.abstract, Signed.abstract, Int64.abstract"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All of these type, except for Int64, are abstract."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A programmer can also define an abstract type and its concrete subtypes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "abstract type PointLike end  # # just a name and position in the type hierarchy\n",
    "\n",
    "struct PointConcrete <: PointLike  # <: is the subtyping operator\n",
    "    x\n",
    "    y\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Declarations\n",
    "\n",
    "The :: operator attaches type annotations to expressions and variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "TypeError: in typeassert, expected Float64, got Int64",
     "output_type": "error",
     "traceback": [
      "TypeError: in typeassert, expected Float64, got Int64",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[1]:1"
     ]
    }
   ],
   "source": [
    "(1 + 2) :: Float64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 + 2) :: Int64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The :: operator can also be appended to the left-hand side of an assignment, or as part of a declaration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "returnfloat (generic function with 1 method)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function returnfloat()\n",
    "    x::Float64 = 100\n",
    "    x\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = returnfloat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A type annotation can also be attached to the header of a function definition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sinc (generic function with 1 method)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function sinc(x)::Float64\n",
    "    if x == 0\n",
    "        return 1\n",
    "    end\n",
    "    sin(x)/(x)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The return value of sinc is always converted to type Float64.\n",
    "\n",
    "The default behavior in Julia when types are omitted is to allow values to be of any type ( Any )."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods\n",
    "\n",
    "In Julia, all named functions are generic functions.  This means that they are built up from many small methods.\n",
    "\n",
    "**A method is a function definition with a specific signature (number and types of arguments)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We previously defined a struct named MyTime and a function named `printtime`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "printtime (generic function with 1 method)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Printf\n",
    "\n",
    "struct MyTime\n",
    "    hour :: Int64\n",
    "    minute :: Int64\n",
    "    second :: Int64\n",
    "end\n",
    "\n",
    "function printtime(time)\n",
    "    @printf(\"%02d:%02d:%02d\", time.hour, time.minute, time.second)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, type declarations can and should be added for performance reasons to the fields in a struct definition.\n",
    "\n",
    "To call this function, you have to pass a MyTime object as an argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyTime(9, 45, 0)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = MyTime(9, 45, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00"
     ]
    }
   ],
   "source": [
    "printtime(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we do not, then we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "ErrorException",
     "evalue": "type String has no field hour",
     "output_type": "error",
     "traceback": [
      "type String has no field hour",
      "",
      "Stacktrace:",
      " [1] getproperty(::Any, ::Symbol) at .\\Base.jl:20",
      " [2] printtime(::String) at .\\In[1]:10",
      " [3] top-level scope at In[4]:1"
     ]
    }
   ],
   "source": [
    "printtime(\"9:45:00\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add a method to the function `printtime` that only accepts as argument a MyTime object, all we have to do is append :: followed by MyTime to the argument time in the function definition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "printtime (generic function with 2 methods)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function printtime(time::MyTime)\n",
    "    @printf(\"%02d:%02d:%02d\", time.hour, time.minute, time.second)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`printtime` is a method with one argument of type MyTime. Calling the function printtime with a MyTime object yields the same result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00"
     ]
    }
   ],
   "source": [
    "printtime(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now redefine the first method without the :: type annotation allowing an argument of any type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "printtime (generic function with 2 methods)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function printtime(time)\n",
    "    println(\"I don't know how to print the argument time.\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you call the function `printtime` with an object different from MyTime , you get now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I don't know how to print the argument time.\n"
     ]
    }
   ],
   "source": [
    "printtime(150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2 methods for generic function <b>printtime</b>:<ul><li> printtime(time::<b>MyTime</b>) in Main at In[5]:2</li> <li> printtime(time) in Main at In[7]:2</li> </ul>"
      ],
      "text/plain": [
       "# 2 methods for generic function \"printtime\":\n",
       "[1] printtime(time::MyTime) in Main at In[5]:2\n",
       "[2] printtime(time) in Main at In[7]:2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(printtime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 17-1\n",
    "\n",
    "Rewrite `timetoint` and `inttotime` to specify their argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inttotime (generic function with 1 method)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function timetoint(time::MyTime)\n",
    "    \n",
    "    minutes = time.hour * 60 + time.minute\n",
    "    seconds = minutes * 60 + time.second\n",
    "    \n",
    "end\n",
    "\n",
    "\n",
    "function inttotime(seconds::Int64)\n",
    "    \n",
    "    (minutes, second) = divrem(seconds, 60)\n",
    "    (hour, minute) = divrem(minutes, 60)\n",
    "    MyTime(hour, minute, second)\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Additional Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here’s a version of increment rewritten to specify its arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "increment (generic function with 1 method)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function increment(time::MyTime, seconds::Int64)\n",
    "    seconds += timetoint(time)\n",
    "    inttotime(seconds)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that now, it is a pure function, not a modifier. Here’s how you would invoke increment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyTime(10, 7, 17)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = MyTime(9, 45, 0)\n",
    "increment(start, 1337)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you put the arguments in the wrong order, you get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching increment(::Int64, ::MyTime)",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching increment(::Int64, ::MyTime)",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[13]:1"
     ]
    }
   ],
   "source": [
    "increment(1337, start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The signature of the method is increment(time::MyTime, seconds::Int64) and not increment(seconds::Int64,\n",
    "time::MyTime).\n",
    "\n",
    "We may use *multiple dispatch* to handle this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "increment (generic function with 2 methods)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function increment(seconds::Int64, time::MyTime)\n",
    "    increment(time, seconds)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyTime(10, 7, 17)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "increment(1337, start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rewriting `isafter` to act only on MyTime objects is as easy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "isafter (generic function with 1 method)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function isafter(t1::MyTime, t2::MyTime)\n",
    "    (t1.hour, t1.minute, t1.second) > (t2.hour, t2.minute, t2.second)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constructor\n",
    "\n",
    "A constructor is a special function that is called to create an object. When we define a type (struct), Julia automatically generates default constructors.\n",
    "\n",
    "The default constructor methods of MyTime have the following signatures:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "MyTime(hour, minute, second)\n",
    "MyTime(hour::Int64, minute::Int64, second::Int64)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already used them to create instances of MyTime.  Note that the default constructor's arguments are the fields of the struct in the order they are listed in the definition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Outer constructor\n",
    "\n",
    "We can also add our own outer constructor methods (defined outside the struct definition), which calls the default (or inner) constructor to construct an instance of a programmer-defined type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyTime"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function MyTime(time::MyTime)\n",
    "    MyTime(time.hour, time.minute, time.second)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3 methods for generic function <b>Type</b>:<ul><li> MyTime(hour::<b>Int64</b>, minute::<b>Int64</b>, second::<b>Int64</b>) in Main at In[1]:4</li> <li> MyTime(time::<b>MyTime</b>) in Main at In[19]:2</li> <li> MyTime(hour, minute, second) in Main at In[1]:4</li> </ul>"
      ],
      "text/plain": [
       "# 3 methods for generic function \"(::Type)\":\n",
       "[1] MyTime(hour::Int64, minute::Int64, second::Int64) in Main at In[1]:4\n",
       "[2] MyTime(time::MyTime) in Main at In[19]:2\n",
       "[3] MyTime(hour, minute, second) in Main at In[1]:4"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(MyTime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This method is called a copy constructor because the new MyTime object is a copy of its argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inner constructor\n",
    "\n",
    "To enforce invariants (conditions that should never change during the execution of a program), we need inner constructor methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct MyTime\n",
    "    \n",
    "    hour :: Int64\n",
    "    minute :: Int64\n",
    "    second :: Int64\n",
    "\n",
    "    function MyTime(hour::Int64=0, minute::Int64=0, second::Int64=0)\n",
    "        @assert(0 ≤ minute < 60, \"Minute is not between 0 and 60.\")\n",
    "        @assert(0 ≤ second < 60, \"Second is not between 0 and 60.\")\n",
    "        new(hour, minute, second)\n",
    "    end\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "6 methods for generic function <b>Type</b>:<ul><li> MyTime() in Main at In[21]:8</li> <li> MyTime(hour::<b>Int64</b>) in Main at In[21]:8</li> <li> MyTime(hour::<b>Int64</b>, minute::<b>Int64</b>) in Main at In[21]:8</li> <li> MyTime(time::<b>MyTime</b>) in Main at In[19]:2</li> <li> MyTime(hour::<b>Int64</b>, minute::<b>Int64</b>, second::<b>Int64</b>) in Main at In[21]:8</li> <li> MyTime(hour, minute, second) in Main at In[1]:4</li> </ul>"
      ],
      "text/plain": [
       "# 6 methods for generic function \"(::Type)\":\n",
       "[1] MyTime() in Main at In[21]:8\n",
       "[2] MyTime(hour::Int64) in Main at In[21]:8\n",
       "[3] MyTime(hour::Int64, minute::Int64) in Main at In[21]:8\n",
       "[4] MyTime(time::MyTime) in Main at In[19]:2\n",
       "[5] MyTime(hour::Int64, minute::Int64, second::Int64) in Main at In[21]:8\n",
       "[6] MyTime(hour, minute, second) in Main at In[1]:4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(MyTime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the inner constructor has optional arguments with default values.  That is why we have 4 methods associated with this inner constructor ( (), (hour::Int64), (hour::Int64, minute::Int64), (hour::Int64, minute::Int64, second::Int64) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An inner constructor method is always defined inside the block of a type declaration and it has access to a special function called `new` that creates objects of the newly declared type.\n",
    "\n",
    "**WARNING**:  The default constructor is not available if any inner constructor is defined. You have to write explicitly all the inner constructors you need."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A second method without arguments of the local function `new` exists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "mutable struct MMyTime\n",
    "    \n",
    "    hour :: Int\n",
    "    minute :: Int\n",
    "    second :: Int\n",
    "    \n",
    "    function MMyTime(hour::Int64=0, minute::Int64=0, second::Int64=0)\n",
    "        @assert(0 ≤ minute < 60, \"Minute is between 0 and 60.\")\n",
    "        @assert(0 ≤ second < 60, \"Second is between 0 and 60.\")\n",
    "        \n",
    "        time = new()\n",
    "        time.hour = hour\n",
    "        time.minute = minute\n",
    "        time.second = second\n",
    "        time\n",
    "    end\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This allows to construct recursive data structures, i.e. a struct where one of the fields is the struct itself. In this case the struct has to be mutable because its fields are modified after instantiation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### show\n",
    "\n",
    "`show` is a special function that returns a string representation of an object. For example, here is a show method for MyTime objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Printf\n",
    "function Base.show(io::IO, time::MyTime)\n",
    "    @printf(io, \"%02d:%02d:%02d\", time.hour, time.minute, time.second)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The prefix Base is needed because we want to add a new method to the Base.show function. \n",
    "\n",
    "When you print an object, Julia invokes the show function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "09:45:00"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time = MyTime(9, 45)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TIP**: When we write a new composite type, we  usually start by writing an outer constructor, which makes it easier to\n",
    "instantiate objects, and `show`, which is useful for debugging."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 17-2\n",
    "\n",
    "Write an inner constructor method for the Point class that takes `x` and `y` as optional parameters and assigns them to the corresponding fields."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Point\n",
    "    \n",
    "    x\n",
    "    y\n",
    "    \n",
    "    function Point(x = 0, y = 0)\n",
    "        print(\"hello from inner  \")\n",
    "        new(x,y)\n",
    "    end\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello from inner  "
     ]
    },
    {
     "data": {
      "text/plain": [
       "Point(1, 0)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 = Point(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3 methods for generic function <b>Type</b>:<ul><li> Point() in Main at In[33]:7</li> <li> Point(x) in Main at In[33]:7</li> <li> Point(x, y) in Main at In[33]:7</li> </ul>"
      ],
      "text/plain": [
       "# 3 methods for generic function \"(::Type)\":\n",
       "[1] Point() in Main at In[33]:7\n",
       "[2] Point(x) in Main at In[33]:7\n",
       "[3] Point(x, y) in Main at In[33]:7"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(Point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to do this using an outer constructor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OuterPoint (generic function with 3 methods)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function OuterPoint(x = 1, y = 1)\n",
    "    Point(x,y)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello from inner  "
     ]
    },
    {
     "data": {
      "text/plain": [
       "Point(1, 1)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = OuterPoint()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3 methods for generic function <b>OuterPoint</b>:<ul><li> OuterPoint() in Main at In[36]:2</li> <li> OuterPoint(x) in Main at In[36]:2</li> <li> OuterPoint(x, y) in Main at In[36]:2</li> </ul>"
      ],
      "text/plain": [
       "# 3 methods for generic function \"OuterPoint\":\n",
       "[1] OuterPoint() in Main at In[36]:2\n",
       "[2] OuterPoint(x) in Main at In[36]:2\n",
       "[3] OuterPoint(x, y) in Main at In[36]:2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(OuterPoint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**CAUTION:** Note that we name this outer constructor `OuterPoint` and NOT `Point`.  \n",
    "\n",
    "***If we had named this `Point`, then it would create an infinite recursion.  This is because the outer constructor and the inner constructor have the same interface in this example.  The outer constructor would recursively call itself rather than the inner constructor.***\n",
    "\n",
    "Well, let's go ahead and see this by defining an outer constructor with the same name and interface as the inner constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#function Point(x = 1, y = 1)\n",
    "    \n",
    "    #print(\"hello from outer \")\n",
    "#    Point(x,y)  \n",
    "    # this was meant to call the inner (or default) constructor but it instead reursively calls the outer constructor.\n",
    "    \n",
    "#end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "#p = Point()  # will give stack overflow error!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#methods(Point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Outer constructors therefore make sense when they have interfaces that do not overlap those of default (or inner) constructors.**\n",
    "\n",
    "See Ch 17 - 2 AdvTypeSystem for further discussion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function Point(x=-10)\n",
    "    \n",
    "    y = 5\n",
    "    Point(x,y)\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3 methods for generic function <b>Type</b>:<ul><li> Point() in Main at In[42]:3</li> <li> Point(x) in Main at In[42]:3</li> <li> Point(x, y) in Main at In[33]:7</li> </ul>"
      ],
      "text/plain": [
       "# 3 methods for generic function \"(::Type)\":\n",
       "[1] Point() in Main at In[42]:3\n",
       "[2] Point(x) in Main at In[42]:3\n",
       "[3] Point(x, y) in Main at In[33]:7"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(Point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello from inner  "
     ]
    },
    {
     "data": {
      "text/plain": [
       "Point(-10, 5)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point()  # we define the outer constructor later.  It calls the inner constructor with (x=-10 and y=5)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operator Overloading\n",
    "\n",
    "By defining operator methods, you can specify the behavior of operators on programmer-defined types. \n",
    "\n",
    "For example, if you define a method named + with two MyTime arguments, you can use the + operator on MyTime objects. Here is what the definition might look like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "+ (generic function with 162 methods)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Base.+\n",
    "function +(t1::MyTime, t2::MyTime)\n",
    "    seconds = timetoint(t1) + timetoint(t2)\n",
    "    inttotime(seconds)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = MyTime(9, 45);\n",
    "duration = MyTime(1, 35, 0);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11:20:00"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start + duration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you apply the + operator to MyTime objects, Julia invokes the newly added method. When the result is shown, Julia invokes `show`. So there is a lot happening behind the scenes!\n",
    "\n",
    "Adding to the behavior of an operator so that it works with programmer-defined types is called **operator overloading**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Dispatch\n",
    "\n",
    "In the previous section we added two MyTime objects, but you also might want to add an integer to a MyTime object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "+ (generic function with 163 methods)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function +(time::MyTime, seconds::Int64)\n",
    "    increment(time, seconds)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10:07:17"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = MyTime(9, 45)\n",
    "start + 1337"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Addition is a commutative operator so we have to add another method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "+ (generic function with 164 methods)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function +(seconds::Int64, time::MyTime)\n",
    "    time + seconds\n",
    "    # or we could do\n",
    "    # increment(seconds, time) or increment(time,seconds)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10:07:17"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1337 + start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The choice of which method to execute when a function is applied is called *dispatch*. \n",
    "\n",
    "Julia allows the dispatch process to choose which of a function’s methods to call based on the number of arguments given, and on the types of all of the function’s arguments. Using all of a function’s arguments to choose which method should be invoked is known as **multiple dispatch**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 17-3\n",
    "\n",
    "Write + methods for point objects:\n",
    "\n",
    "If both operands are point objects, the method should return a new point object whose `x` coordinate is the sum of the\n",
    "`x` coordinates of the operands, and likewise for the `y` coordinates.\n",
    "\n",
    "If the first or the second operand is a tuple, the method should add the first element of the tuple to the `x` coordinate\n",
    "and the second element to the `y` coordinate, and return a new point object with the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "+ (generic function with 167 methods)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function +(p1::Point, p2::Point)\n",
    "    x = p1.x + p2.x\n",
    "    y = p1.y + p2.y\n",
    "    Point(x,y)\n",
    "end\n",
    "\n",
    "\n",
    "function +(t::Tuple, p::Point)\n",
    "    x = t[1] + p.x\n",
    "    y = t[2] + p.y\n",
    "    Point(x,y)\n",
    "end\n",
    "\n",
    "\n",
    "function +(p::Point, t::Tuple)\n",
    "#     x = t[1] + p.x\n",
    "#     y = t[2] + p.y\n",
    "#     Point(x,y)\n",
    "    \n",
    "    t + p # since Tuple + Point was defined above\n",
    "    \n",
    "end\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(4, 6)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 = Point(1,2)\n",
    "p2 = Point(3,4)\n",
    "\n",
    "p1+p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(6, 8)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 + (5,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(6, 8)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5,6) + p1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generic Programming\n",
    "\n",
    "Multiple dispatch is useful when it is necessary, but (fortunately) it is not always necessary. Often you can avoid it by writing functions that work correctly for arguments with different types. Many of the functions we wrote for strings also work for other sequence types. For example, in Dictionary as a Collection of Counters we used histogram to count the number of times each letter appears in a word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "histogram (generic function with 1 method)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function histogram(s)\n",
    "    d = Dict()\n",
    "    for c in s\n",
    "        if c ∉ keys(d)\n",
    "            d[c] = 1\n",
    "        else\n",
    "            d[c] += 1\n",
    "        end\n",
    "    end\n",
    "    d\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function also works for lists, tuples, and even dictionaries, as long as the elements of `s` are hashable, so they can be\n",
    "used as keys in `d`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Any,Any} with 3 entries:\n",
       "  \"bacon\" => 1\n",
       "  \"spam\"  => 4\n",
       "  \"egg\"   => 1"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (\"spam\", \"egg\", \"spam\", \"spam\", \"bacon\", \"spam\")\n",
    "histogram(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Polymorphism\n",
    "\n",
    "Functions that work with several types are called polymorphic.  Polymorphism can facilitate code reuse. \n",
    "\n",
    "We have already seen an example of polymorphic behavior when we overloaded `+` operator such that it works on instances of MyTime.\n",
    "\n",
    "As another example, the built-in function `sum`, which adds the elements of a sequence, works as long as the elements of the sequence support addition.  Since a + method is provided for MyTime objects, they work with `sum`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "03:17:10"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = MyTime(1, 7, 2)\n",
    "t2 = MyTime(1, 5, 8)\n",
    "t3 = MyTime(1, 5, 0)\n",
    "sum((t1, t2, t3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, if all of the operations inside a function work with a given type, the function works with that type.\n",
    "\n",
    "The best kind of polymorphism is the unintentional kind, where you discover that a function you already wrote can be applied to a type you never planned for."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interface and Implementation\n",
    "\n",
    "One of the goals of multiple dispatch is to make software more maintainable, which means that you can keep the program working when other parts of the system change, and modify the program to meet new requirements. A design principle that helps achieve that goal is to keep interfaces separate from implementations. This means that the methods having an argument annotated with a type should not depend on how the fields of that type are represented.\n",
    "\n",
    "After you deploy a new type, you might discover a better implementation. If other parts of the program are using your type, it might be time-consuming and error-prone to change the interface. \n",
    "\n",
    "But if you designed the interface carefully, you can change the implementation without changing the interface, which means that other parts of the program don’t have to change.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Tiger(3.5, \"orange\")"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct Tiger\n",
    "    taillength::Float64\n",
    "    coatcolor  # not including a type annotation is the same as `::Any`\n",
    "end\n",
    "\n",
    "tigger = Tiger(3.5, \"orange\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0-element Array{Any,1}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstract type Cat end\n",
    "subtypes(Cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Lion <: Cat  # Lion is a subtype of Cat\n",
    "    maneColor\n",
    "    roar::AbstractString\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{Any,1}:\n",
       " Lion"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subtypes(Cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Lion"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Lion(roar::AbstractString) = Lion(\"green\", roar)\n",
    "# This is an outer constructor because it's outside the type definition.\n",
    "# Note that this outer constructor has only one argument (as opposed to two in the default constructors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Panther <: Cat  # Panther is also a subtype of Cat\n",
    "    eyeColor\n",
    "    Panther() = new(\"green\")\n",
    "    # Panthers will only have this inner constructor, and no default constructor!!\n",
    "end\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "meow (generic function with 3 methods)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function meow(animal::Lion)\n",
    "    animal.roar  # access type properties using dot notation\n",
    "end\n",
    "\n",
    "function meow(animal::Panther)\n",
    "    \"grrr\"\n",
    "end\n",
    "\n",
    "function meow(animal::Tiger)\n",
    "    \"rawwwr\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"rawwwr\", \"ROAAR\", \"grrr\")"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meow(tigger), meow(Lion(\"brown\", \"ROAAR\")), meow(Panther())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(false, true, true)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Review the local type hierarchy\n",
    "Tiger <: Cat, Lion <: Cat, Panther <: Cat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pet_cat (generic function with 1 method)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function pet_cat(cat::Cat)\n",
    "    println(\"The cat says $(meow(cat))\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cat says 42\n"
     ]
    }
   ],
   "source": [
    "pet_cat(Lion(\"42\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching pet_cat(::Tiger)\nClosest candidates are:\n  pet_cat(!Matched::Cat) at In[11]:2",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching pet_cat(::Tiger)\nClosest candidates are:\n  pet_cat(!Matched::Cat) at In[11]:2",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[13]:1"
     ]
    }
   ],
   "source": [
    "pet_cat(tigger)  # well, we did not define Tiger as a sub-type of Cat (yes, this is an intentional error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fight (generic function with 1 method)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's define a function with more arguments, so we can see the difference\n",
    "\n",
    "function fight(t::Tiger, c::Cat)\n",
    "    println(\"The $(t.coatcolor) tiger wins!\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The orange tiger wins!\n",
      "The orange tiger wins!\n"
     ]
    }
   ],
   "source": [
    "fight(tigger, Panther())\n",
    "fight(tigger, Lion(\"ROAR\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's change the behavior when the Cat is specifically a Lion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fight (generic function with 2 methods)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fight(t::Tiger, l::Lion) = println(\"The $(l.maneColor)-maned lion wins!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2 methods for generic function <b>fight</b>:<ul><li> fight(t::<b>Tiger</b>, l::<b>Lion</b>) in Main at In[17]:1</li> <li> fight(t::<b>Tiger</b>, c::<b>Cat</b>) in Main at In[14]:4</li> </ul>"
      ],
      "text/plain": [
       "# 2 methods for generic function \"fight\":\n",
       "[1] fight(t::Tiger, l::Lion) in Main at In[17]:1\n",
       "[2] fight(t::Tiger, c::Cat) in Main at In[14]:4"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(fight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The orange tiger wins!\n"
     ]
    }
   ],
   "source": [
    "fight(tigger, Panther())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The green-maned lion wins!\n"
     ]
    }
   ],
   "source": [
    "fight(tigger, Lion(\"ROAR\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching fight(::Panther, ::Tiger)",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching fight(::Panther, ::Tiger)",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[25]:1"
     ]
    }
   ],
   "source": [
    "fight(Panther(), tigger)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fight (generic function with 3 methods)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fight(l::Lion, c::Cat) = println(\"The victorious cat says $(meow(c))\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3 methods for generic function <b>fight</b>:<ul><li> fight(t::<b>Tiger</b>, l::<b>Lion</b>) in Main at In[17]:1</li> <li> fight(t::<b>Tiger</b>, c::<b>Cat</b>) in Main at In[14]:4</li> <li> fight(l::<b>Lion</b>, c::<b>Cat</b>) in Main at In[21]:1</li> </ul>"
      ],
      "text/plain": [
       "# 3 methods for generic function \"fight\":\n",
       "[1] fight(t::Tiger, l::Lion) in Main at In[17]:1\n",
       "[2] fight(t::Tiger, c::Cat) in Main at In[14]:4\n",
       "[3] fight(l::Lion, c::Cat) in Main at In[21]:1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(fight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The victorious cat says grrr\n"
     ]
    }
   ],
   "source": [
    "fight(Lion(\"balooga!\"), Panther())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching fight(::Panther, ::Lion)\nClosest candidates are:\n  fight(!Matched::Tiger, ::Lion) at In[17]:1\n  fight(!Matched::Tiger, ::Cat) at In[14]:4\n  fight(!Matched::Lion, ::Cat) at In[21]:1",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching fight(::Panther, ::Lion)\nClosest candidates are:\n  fight(!Matched::Tiger, ::Lion) at In[17]:1\n  fight(!Matched::Tiger, ::Cat) at In[14]:4\n  fight(!Matched::Lion, ::Cat) at In[21]:1",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[26]:1"
     ]
    }
   ],
   "source": [
    "fight(Panther(), Lion(\"RAWR\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fight (generic function with 4 methods)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fight(c::Cat, l::Lion) = println(\"The cat beats the Lion\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cat beats the Lion\n"
     ]
    }
   ],
   "source": [
    "fight(Panther(), Lion(\"RAWR\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "4 methods for generic function <b>fight</b>:<ul><li> fight(t::<b>Tiger</b>, l::<b>Lion</b>) in Main at In[17]:1</li> <li> fight(t::<b>Tiger</b>, c::<b>Cat</b>) in Main at In[14]:4</li> <li> fight(l::<b>Lion</b>, c::<b>Cat</b>) in Main at In[21]:1</li> <li> fight(c::<b>Cat</b>, l::<b>Lion</b>) in Main at In[27]:1</li> </ul>"
      ],
      "text/plain": [
       "# 4 methods for generic function \"fight\":\n",
       "[1] fight(t::Tiger, l::Lion) in Main at In[17]:1\n",
       "[2] fight(t::Tiger, c::Cat) in Main at In[14]:4\n",
       "[3] fight(l::Lion, c::Cat) in Main at In[21]:1\n",
       "[4] fight(c::Cat, l::Lion) in Main at In[27]:1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(fight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: fight(::Lion, ::Lion) is ambiguous. Candidates:\n  fight(c::Cat, l::Lion) in Main at In[27]:1\n  fight(l::Lion, c::Cat) in Main at In[21]:1\nPossible fix, define\n  fight(::Lion, ::Lion)",
     "output_type": "error",
     "traceback": [
      "MethodError: fight(::Lion, ::Lion) is ambiguous. Candidates:\n  fight(c::Cat, l::Lion) in Main at In[27]:1\n  fight(l::Lion, c::Cat) in Main at In[21]:1\nPossible fix, define\n  fight(::Lion, ::Lion)",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[31]:1"
     ]
    }
   ],
   "source": [
    "fight(Lion(\"RAR\"), Lion(\"brown\", \"rarrr\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The lions come to a tie\n"
     ]
    }
   ],
   "source": [
    "fight(l::Lion, l2::Lion) = println(\"The lions come to a tie\") \n",
    "\n",
    "fight(Lion(\"RAR\"), Lion(\"brown\", \"rarrr\"))"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.4.0",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}