more_julia/generic_programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<a id='generic-programming'></a>\n",
    "<div id=\"qe-notebook-header\" style=\"text-align:right;\">\n",
    "        <a href=\"https://quantecon.org/\" title=\"quantecon.org\">\n",
    "                <img style=\"width:250px;display:inline;\" src=\"https://assets.quantecon.org/img/qe-menubar-logo.svg\" alt=\"QuantEcon\">\n",
    "        </a>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generic Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "\n",
    "- [Generic Programming](#Generic-Programming)  \n",
    "  - [Overview](#Overview)  \n",
    "  - [Exploring Type Trees](#Exploring-Type-Trees)  \n",
    "  - [Distributions](#Distributions)  \n",
    "  - [Numbers and Algebraic Structures](#Numbers-and-Algebraic-Structures)  \n",
    "  - [Reals and Algebraic Structures](#Reals-and-Algebraic-Structures)  \n",
    "  - [Functions, and Function-Like Types](#Functions,-and-Function-Like-Types)  \n",
    "  - [Limitations of Dispatching on Abstract Types](#Limitations-of-Dispatching-on-Abstract-Types)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> I find OOP methodologically wrong. It starts with classes. It is as if mathematicians would start with axioms. You do not start with axioms - you start with proofs. Only when you have found a bunch of related proofs, can you come up with axioms. You end with axioms. The same thing is true in programming: you have to start with interesting algorithms. Only when you understand them well, can you come up with an interface that will let them work. – Alexander Stepanov"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "In this lecture we delve more deeply into the structure of Julia, and in particular into\n",
    "\n",
    "- abstract and concrete types  \n",
    "- the type tree  \n",
    "- designing and using generic interfaces  \n",
    "- the role of generic interfaces in Julia performance  \n",
    "\n",
    "\n",
    "Understanding them will help you\n",
    "\n",
    "- form a “mental model” of the Julia language  \n",
    "- design code that matches the “white-board” mathematics  \n",
    "- create code that can use (and be used by) a variety of other packages  \n",
    "- write “well organized” Julia code that’s easy to read, modify, maintain and debug  \n",
    "- improve the speed at which your code runs  \n",
    "\n",
    "\n",
    "(Special thank you to Jeffrey Sarnoff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generic Programming is an Attitude\n",
    "\n",
    "From *Mathematics to Generic Programming* [[SR14]](https://lectures.quantecon.org/zreferences.html#stepanov-mathematics-2014)\n",
    "\n",
    "> Generic programming is an approach to programming that focuses on designing algorithms and data structures so that they work in the most general setting without loss of efficiency… Generic programming is more of an *attitude* toward programming than a particular set of tools.\n",
    "\n",
    "\n",
    "In that sense, it is important to think of generic programming as an interactive approach to uncover generality without compromising performance rather than as a set of rules\n",
    "\n",
    "As we will see, the core approach is to treat data structures and algorithms as loosely coupled, and is in direct contrast to the [is-a](https://en.wikipedia.org/wiki/Is-a)  approach of object-oriented programming\n",
    "\n",
    "This lecture has the dual role of giving an introduction into the design of generic algorithms and describing how Julia helps make that possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide-output": true
   },
   "outputs": [],
   "source": [
    "using InstantiateFromURL\n",
    "github_project(\"QuantEcon/quantecon-notebooks-julia\", version = \"0.3.0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide-output": true
   },
   "outputs": [],
   "source": [
    "using LinearAlgebra, Statistics\n",
    "using Distributions, Plots, QuadGK, Polynomials, Interpolations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploring Type Trees\n",
    "\n",
    "The connection between data structures and the algorithms which operate on them is handled by the type system\n",
    "\n",
    "Concrete types (i.e., `Float64` or `Array{Float64, 2}`) are the data structures we apply an algorithm to, and the abstract types (e.g. the corresponding `Number` and `AbstractArray`) provide the mapping between a set of related data structures and algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(x, y, z) = (1, Normal{Float64}(μ=0.0, σ=1.0), \"foo\")\n",
      "(typeof(x), typeof(y), typeof(z)) = "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Int64, Normal{Float64}, String)\n",
      "supertype(typeof(x)) = Signed\n",
      "typeof(x) |> supertype = Signed\n",
      "supertype(typeof(y)) = Distribution{Univariate,Continuous}\n",
      "typeof(z) |> supertype = AbstractString\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "typeof(x) <: Any = true\n"
     ]
    }
   ],
   "source": [
    "using Distributions\n",
    "x = 1\n",
    "y = Normal()\n",
    "z = \"foo\"\n",
    "@show x, y, z\n",
    "@show typeof(x), typeof(y), typeof(z)\n",
    "@show supertype(typeof(x))\n",
    "\n",
    "# pipe operator, |>, is is equivalent\n",
    "@show typeof(x) |> supertype\n",
    "@show supertype(typeof(y))\n",
    "@show typeof(z) |> supertype\n",
    "@show typeof(x) <: Any;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beyond the `typeof` and `supertype` functions, a few other useful tools for analyzing the tree of types are discussed in the [introduction to types lecture](https://lectures.quantecon.org/getting_started_julia/introduction_to_types.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Int64 <: Signed <: Integer <: Real <: Number <: Any"
     ]
    }
   ],
   "source": [
    "using Base: show_supertypes # import the function from the `Base` package\n",
    "\n",
    "show_supertypes(Int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Any,1}:\n",
       " Bool                       \n",
       " GeometryTypes.OffsetInteger\n",
       " Signed                     \n",
       " Unsigned                   "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subtypes(Integer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `subtypes` function, we can write an algorithm to traverse the type tree below any time `t` – with the confidence that all types support `subtypes`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "subtypetree (generic function with 3 methods)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  from https://github.com/JuliaLang/julia/issues/24741\n",
    "function subtypetree(t, level=1, indent=4)\n",
    "        if level == 1\n",
    "            println(t)\n",
    "        end\n",
    "        for s in subtypes(t)\n",
    "            println(join(fill(\" \", level * indent)) * string(s))  # print type\n",
    "            subtypetree(s, level+1, indent)  # recursively print the next type, indenting\n",
    "        end\n",
    "    end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Applying this to `Number`, we see the tree of types currently loaded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Complex\n",
      "    Real\n",
      "        AbstractFloat\n",
      "            BigFloat\n",
      "            Float16\n",
      "            Float32\n",
      "            Float64\n",
      "        AbstractIrrational\n",
      "            Irrational\n",
      "        FixedPointNumbers.FixedPoint\n",
      "            FixedPointNumbers.Fixed\n",
      "            FixedPointNumbers.Normed\n",
      "        Integer\n",
      "            Bool\n",
      "            GeometryTypes.OffsetInteger\n",
      "            Signed\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                BigInt\n",
      "                Int128\n",
      "                Int16\n",
      "                Int32\n",
      "                Int64\n",
      "                Int8\n",
      "            Unsigned\n",
      "                UInt128\n",
      "                UInt16\n",
      "                UInt32\n",
      "                UInt64\n",
      "                UInt8\n",
      "        Rational\n",
      "        Ratios.SimpleRatio\n",
      "        StatsBase.TestStat\n"
     ]
    }
   ],
   "source": [
    "subtypetree(Number) # warning: do not use this function on ``Any``!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the most part, all of the “leaves” will be concrete types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Any\n",
    "\n",
    "At the root of all types is `Any`\n",
    "\n",
    "There are a few functions that work in the “most generalized” context: usable with anything that you can construct or access from other packages\n",
    "\n",
    "We have already called `typeof`, `show` and `supertype` – which will apply to a custom `struct` type since `MyType <: Any`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myval = MyType(2.0)\n",
      "typeof(myval) = MyType\n",
      "supertype(typeof(myval)) = Any\n",
      "typeof(myval) <: Any = true\n"
     ]
    }
   ],
   "source": [
    "# custom type\n",
    "struct MyType\n",
    "    a::Float64\n",
    "end\n",
    "\n",
    "myval = MyType(2.0)\n",
    "@show myval\n",
    "@show typeof(myval)\n",
    "@show supertype(typeof(myval))\n",
    "@show typeof(myval) <: Any;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see another example of generic programming: every type `<: Any` supports the `@show` macro, which in turn, relies on the `show` function\n",
    "\n",
    "The `@show` macro (1) prints the expression as a string; (2) evaluates the expression; and (3) calls the `show` function on the returned values\n",
    "\n",
    "To see this with built-in types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]"
     ]
    }
   ],
   "source": [
    "x = [1, 2]\n",
    "show(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Any` type is useful, because it provides a fall-back implementation for a variety of functions\n",
    "\n",
    "Hence, calling `show` on our custom type dispatches to the fallback function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MyType(2.0)"
     ]
    }
   ],
   "source": [
    "myval = MyType(2.0)\n",
    "show(myval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default fallback implementation used by Julia would be roughly equivalent to"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```julia\n",
    "function show(io::IO, x)\n",
    "    str = string(x)\n",
    "    print(io, str)\n",
    "end\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To implement a specialized implementation of the `show` function for our type, rather than using this fallback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(MyType.a = 2.0)"
     ]
    }
   ],
   "source": [
    "import Base.show  # to extend an existing function\n",
    "\n",
    "function show(io::IO, x::MyType)\n",
    "    str = \"(MyType.a = $(x.a))\"  # custom display\n",
    "    print(io, str)\n",
    "end\n",
    "show(myval)  # it creates an IO value first and then calls the above show"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At that point, we can use the `@show` macro, which in turn calls `show`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myval = (MyType.a = 2.0)\n"
     ]
    }
   ],
   "source": [
    "@show myval;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see another example of generic programming: any type with a `show` function works with `@show`\n",
    "\n",
    "Layering of functions (e.g. `@show` calling `show`) with a “fallback” implementation makes it possible for new types to be designed and only specialized where necessary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unlearning Object Oriented (OO) Programming (Advanced)\n",
    "\n",
    "See [Types](https://docs.julialang.org/en/v1/manual/types/#man-types-1) for more on OO vs. generic types\n",
    "\n",
    "If you have never used programming languages such as C++, Java, and Python, then the type hierarchies above may seem unfamiliar and abstract\n",
    "\n",
    "In that case, keep an open mind that this discussion of abstract concepts will have practical consequences, but there is no need to read this section\n",
    "\n",
    "Otherwise, if you have used object-oriented programming (OOP) in those languages, then some of the concepts in these lecture notes will appear familiar\n",
    "\n",
    "**Don’t be fooled!**\n",
    "\n",
    "The superficial similarity can lead to misuse: types are *not* classes with poor encapsulation, and methods are *not* the equivalent to member functions with the order of arguments swapped\n",
    "\n",
    "In particular, previous OO knowledge often leads people to write Julia code such as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m.algorithmcalculation = 7.199999999999999\n"
     ]
    }
   ],
   "source": [
    "# BAD! Replicating an OO design in Julia\n",
    "mutable struct MyModel\n",
    "    a::Float64\n",
    "    b::Float64\n",
    "    algorithmcalculation::Float64\n",
    "\n",
    "    MyModel(a, b) = new(a, b, 0.0) # an inner constructor\n",
    "end\n",
    "\n",
    "function myalgorithm!(m::MyModel, x)\n",
    "    m.algorithmcalculation = m.a + m.b + x # some algorithm\n",
    "end\n",
    "\n",
    "function set_a!(m::MyModel, a)\n",
    "    m.a = a\n",
    "end\n",
    "\n",
    "m = MyModel(2.0, 3.0)\n",
    "x = 0.1\n",
    "set_a!(m, 4.1)\n",
    "myalgorithm!(m, x)\n",
    "@show m.algorithmcalculation;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may think to yourself that the above code is similar to OO, except that you\n",
    "* reverse the first argument, i.e., `myalgorithm!(m, x)` instead of the object-oriented `m.myalgorithm!(x)`\n",
    "* cannot control encapsulation of the fields `a`, `b`, but you can add getter/setters like `set_a`\n",
    "* do not have concrete inheritance\n",
    "\n",
    "While this sort of programming is possible, it is (verbosely) missing the point of Julia and the power of generic programming\n",
    "\n",
    "When programming in Julia\n",
    "\n",
    "> - there is no [encapsulation](https://en.wikipedia.org/wiki/Encapsulation_%28computer_programming%29) and most custom types you create will be immutable  \n",
    "- [Polymorphism](https://en.wikipedia.org/wiki/Polymorphism_%28computer_science%29) is achieved without anything resembling OOP [inheritance](https://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29)  \n",
    "- [Abstraction](https://en.wikipedia.org/wiki/Abstraction_%28computer_science%29#Abstraction_in_object_oriented_programming) is implemented by keeping the data and algorithms that operate on them as orthogonal as possible – in direct contrast to OOP’s association of algorithms and methods directly with a type in a tree  \n",
    "- The supertypes in Julia are simply used for selecting which specialized algorithm to use (i.e., part of generic polymorphism) and have nothing to do with OO inheritance  \n",
    "- The looseness that accompanies keeping algorithms and data structures as orthogonal as possible makes it easier to discover commonality in the design  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterative Design of Abstractions\n",
    "\n",
    "As its essence, the design of generic software is that you will start with creating algorithms which are largely orthogonal to concrete types\n",
    "\n",
    "In the process, you will discover commonality which leads to abstract types with informally defined functions operating on them\n",
    "\n",
    "Given the abstract types and commonality, you then refine the algorithms as they are more limited or more general than you initially thought\n",
    "\n",
    "This approach is in direct contrast to object-oriented design and analysis ([OOAD](https://en.wikipedia.org/wiki/Object-oriented_analysis_and_design))\n",
    "\n",
    "With that, where you specify a taxonomies of types, add operations to those types, and then move down to various levels of specialization (where algorithms are embedded at points within the taxonomy, and potentially specialized with inheritance)\n",
    "\n",
    "In the examples that follow, we will show for exposition the hierarchy of types and the algorithms operating on them, but the reality is that the algorithms are often designed first, and the abstact types came later"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Distributions\n",
    "\n",
    "First, consider working with “distributions”\n",
    "\n",
    "Algorithms using distributions might (1) draw random numbers for Monte-Carlo methods; and (2) calculate the pdf or cdf – if it is defined\n",
    "\n",
    "The process of using concrete distributions in these sorts of applications led\n",
    "to the creation of the [Distributions.jl](https://github.com/JuliaStats/Distributions.jl) package\n",
    "\n",
    "Let’s examine the tree of types for a Normal distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d1 = Normal{Float64}(μ=1.0, σ=2.0)\n",
      "Normal{Float64} <: Distribution{Univariate,Continuous} <: Sampleable{Univariate,Continuous} <: Any"
     ]
    }
   ],
   "source": [
    "using Distributions\n",
    "d1 = Normal(1.0, 2.0) # an example type to explore\n",
    "@show d1\n",
    "show_supertypes(typeof(d1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Sampleable{Univariate,Continuous}` type has a limited number of functions, chiefly the ability to draw a random number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rand(d1) = 1.515582408143116\n"
     ]
    }
   ],
   "source": [
    "@show rand(d1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The purpose of that abstract type is to provide an interface for drawing from a\n",
    "variety of distributions, some of which may not have a well-defined predefined pdf\n",
    "\n",
    "If you were writing a function to simulate a stochastic process with arbitrary\n",
    "iid shocks, where you did not need to assume an existing pdf etc., this is a natural candidate\n",
    "\n",
    "For example, to simulate $ x_{t+1} = a x_t + b \\epsilon_{t+1} $ where\n",
    "$ \\epsilon \\sim D $ for some $ D $, which allows drawing random values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulateprocess(0.0, d=Normal(0.2, 2.0)) = [0.0, 0.2966730564239772, -0.8999127311098278, -1.4134524316043342, -3.5193326811055154, -4.382223566893675]\n"
     ]
    }
   ],
   "source": [
    "function simulateprocess(x₀; a = 1.0, b = 1.0, N = 5, d::Sampleable{Univariate,Continuous})\n",
    "    x = zeros(typeof(x₀), N+1) # preallocate vector, careful on the type\n",
    "    x[1] = x₀\n",
    "    for t in 2:N+1\n",
    "        x[t] = a * x[t-1] + b * rand(d) # draw\n",
    "    end\n",
    "    return x\n",
    "end\n",
    "@show simulateprocess(0.0, d=Normal(0.2, 2.0));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Sampleable{Univariate,Continuous}` and, especially, the `Sampleable{Multivariate,Continuous}` abstract types are useful generic interfaces for Monte-Carlo and Bayesian methods\n",
    "\n",
    "Moving down the tree, the `Distributions{Univariate, Continuous}` abstract type has other functions we can use for generic algorithms operating on distributions\n",
    "\n",
    "These match the mathematics, such as `pdf`, `cdf`, `quantile`, `support`, `minimum`, `maximum`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d1 = Normal{Float64}(μ=1.0, σ=2.0)\n",
      "d2 = "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exponential{Float64}(θ=0.1)\n",
      "supertype(typeof(d1)) = Distribution{Univariate,Continuous}\n",
      "supertype(typeof(d2)) = Distribution{Univariate,Continuous}\n",
      "pdf(d1, 0.1) = 0.18026348123082397\n",
      "pdf(d2, 0.1) = 3.6787944117144233\n",
      "cdf(d1, 0.1) = 0.32635522028792\n",
      "cdf(d2, 0.1) = 0.6321205588285577\n",
      "support(d1) = RealInterval(-Inf, Inf)\n",
      "support(d2) = RealInterval(0.0, Inf)\n",
      "minimum(d1) = -Inf\n",
      "minimum(d2) = 0.0\n",
      "maximum(d1) = Inf\n",
      "maximum(d2) = Inf\n"
     ]
    }
   ],
   "source": [
    "d1 = Normal(1.0, 2.0)\n",
    "d2 = Exponential(0.1)\n",
    "@show d1\n",
    "@show d2\n",
    "@show supertype(typeof(d1))\n",
    "@show supertype(typeof(d2))\n",
    "\n",
    "@show pdf(d1, 0.1)\n",
    "@show pdf(d2, 0.1)\n",
    "@show cdf(d1, 0.1)\n",
    "@show cdf(d2, 0.1)\n",
    "@show support(d1)\n",
    "@show support(d2)\n",
    "@show minimum(d1)\n",
    "@show minimum(d2)\n",
    "@show maximum(d1)\n",
    "@show maximum(d2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could create your own `Distributions{Univariate, Continuous}` type by implementing those functions – as is described in [the documentation](https://juliastats.github.io/Distributions.jl/latest/extends/)\n",
    "\n",
    "If you fulfill all of the conditions of a particular interface, you can use algorithms from the present, past, and future  that are written for the abstract `Distributions{Univariate, Continuous}` type\n",
    "\n",
    "As an example, consider the [StatsPlots](https://github.com/JuliaPlots/StatsPlots.jl) package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip3600\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip3600)\" points=\"\n",
       "0,1600 2400,1600 2400,0 0,0 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip3601\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip3600)\" points=\"\n",
       "153.898,1487.47 2352.76,1487.47 2352.76,47.2441 153.898,47.2441 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip3602\">\n",
       "    <rect x=\"153\" y=\"47\" width=\"2200\" height=\"1441\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  408.691,1487.47 408.691,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  690.751,1487.47 690.751,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  972.811,1487.47 972.811,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1254.87,1487.47 1254.87,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1536.93,1487.47 1536.93,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1818.99,1487.47 1818.99,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2101.05,1487.47 2101.05,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  153.898,1448.26 2352.76,1448.26 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  153.898,1107.24 2352.76,1107.24 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  153.898,766.213 2352.76,766.213 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  153.898,425.191 2352.76,425.191 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  153.898,84.1691 2352.76,84.1691 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  153.898,1487.47 2352.76,1487.47 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  153.898,1487.47 153.898,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  408.691,1487.47 408.691,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  690.751,1487.47 690.751,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  972.811,1487.47 972.811,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1254.87,1487.47 1254.87,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1536.93,1487.47 1536.93,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1818.99,1487.47 1818.99,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2101.05,1487.47 2101.05,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  153.898,1448.26 186.881,1448.26 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  153.898,1107.24 186.881,1107.24 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  153.898,766.213 186.881,766.213 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  153.898,425.191 186.881,425.191 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  153.898,84.1691 186.881,84.1691 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 408.691, 1541.47)\" x=\"408.691\" y=\"1541.47\">-1</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 690.751, 1541.47)\" x=\"690.751\" y=\"1541.47\">0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 972.811, 1541.47)\" x=\"972.811\" y=\"1541.47\">1</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1254.87, 1541.47)\" x=\"1254.87\" y=\"1541.47\">2</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1536.93, 1541.47)\" x=\"1536.93\" y=\"1541.47\">3</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1818.99, 1541.47)\" x=\"1818.99\" y=\"1541.47\">4</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 2101.05, 1541.47)\" x=\"2101.05\" y=\"1541.47\">5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 129.898, 1465.76)\" x=\"129.898\" y=\"1465.76\">0.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 129.898, 1124.74)\" x=\"129.898\" y=\"1124.74\">0.1</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 129.898, 783.713)\" x=\"129.898\" y=\"783.713\">0.2</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 129.898, 442.691)\" x=\"129.898\" y=\"442.691\">0.3</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 129.898, 101.669)\" x=\"129.898\" y=\"101.669\">0.4</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip3602)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  216.13,1446.71 226.374,1446.49 321.096,1442.58 415.819,1431.96 472.743,1419.15 529.667,1398.34 577.796,1371.97 625.925,1335.02 652.065,1309.62 678.206,1279.97 \n",
       "  704.347,1245.74 730.487,1206.62 754.587,1166.06 778.686,1121.08 802.785,1071.69 826.885,1017.99 878.559,889.561 930.233,746.74 990.102,572.562 1049.97,403.293 \n",
       "  1076.57,334.155 1103.18,270.962 1129.78,215.201 1156.38,168.237 1179.71,135.231 1203.04,110.555 1226.37,94.7059 1249.69,88.0053 1275.13,91.2801 1300.56,105.509 \n",
       "  1325.99,130.349 1351.43,165.204 1377.01,209.539 1402.6,262.142 1428.18,321.818 1453.77,387.257 1510.34,545.537 1566.92,710.492 1620.75,861.693 1674.58,998.587 \n",
       "  1702.56,1062.21 1730.55,1120.08 1758.53,1172.01 1786.52,1217.99 1833.63,1282.52 1880.75,1332.24 1938.27,1375.99 1995.79,1405.07 2049.86,1422.63 2103.94,1433.6 \n",
       "  2190.56,1442.71 2277.19,1446.35 2290.52,1446.65 \n",
       "  \"/>\n",
       "<polygon clip-path=\"url(#clip3600)\" points=\"\n",
       "1989.93,251.724 2280.76,251.724 2280.76,130.764 1989.93,130.764 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1989.93,251.724 2280.76,251.724 2280.76,130.764 1989.93,130.764 1989.93,251.724 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip3600)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2013.93,191.244 2157.93,191.244 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip3600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2181.93, 208.744)\" x=\"2181.93\" y=\"208.744\">y1</text>\n",
       "</g>\n",
       "</svg>\n"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using StatsPlots\n",
    "d = Normal(2.0, 1.0)\n",
    "plot(d) # note no other arguments!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling `plot` on any subtype of `Distributions{Univariate, Continuous}`\n",
    "displays the `pdf` and uses `minimum` and `maximum` to determine the range\n",
    "\n",
    "Let’s create our own distribution type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "struct OurTruncatedExponential <: Distribution{Univariate,Continuous}\n",
    "    α::Float64\n",
    "    xmax::Float64\n",
    "end\n",
    "Distributions.pdf(d::OurTruncatedExponential, x) = d.α *exp(-d.α * x)/exp(-d.α * d.xmax)\n",
    "Distributions.minimum(d::OurTruncatedExponential) = 0\n",
    "Distributions.maximum(d::OurTruncatedExponential) = d.xmax\n",
    "# ... more to have a complete type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To demonstrate this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(minimum(d), maximum(d)) = (0, 2.0)\n",
      "support(d) = "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RealInterval(0.0, 2.0)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "RealInterval(0.0, 2.0)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = OurTruncatedExponential(1.0,2.0)\n",
    "@show minimum(d), maximum(d)\n",
    "@show support(d) # why does this work?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Curiously, you will note that the `support` function works, even though we did not provide one\n",
    "\n",
    "This is another example of the power of multiple dispatch and generic programming\n",
    "\n",
    "In the background, the `Distributions.jl` package  has something like the following implemented"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```julia\n",
    "    Distributions.support(d::Distribution) = RealInterval(minimum(d), maximum(d))\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since `OurTruncatedExponential <: Distribution`, and we\n",
    "implemented `minimum` and `maximum`, calls to `support` get this\n",
    "implementation as a fallback\n",
    "\n",
    "These functions are enough to use the  `StatsPlots.jl` package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip4000\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip4000)\" points=\"\n",
       "0,1600 2400,1600 2400,0 0,0 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip4001\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip4000)\" points=\"\n",
       "113.754,1487.47 2352.76,1487.47 2352.76,47.2441 113.754,47.2441 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip4002\">\n",
       "    <rect x=\"113\" y=\"47\" width=\"2240\" height=\"1441\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  156.02,1487.47 156.02,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  696.228,1487.47 696.228,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1236.44,1487.47 1236.44,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1776.64,1487.47 1776.64,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2316.85,1487.47 2316.85,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  113.754,1452.34 2352.76,1452.34 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  113.754,1233.91 2352.76,1233.91 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  113.754,1015.48 2352.76,1015.48 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  113.754,797.053 2352.76,797.053 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  113.754,578.624 2352.76,578.624 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  113.754,360.196 2352.76,360.196 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  113.754,141.768 2352.76,141.768 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  113.754,1487.47 2352.76,1487.47 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  113.754,1487.47 113.754,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  156.02,1487.47 156.02,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  696.228,1487.47 696.228,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1236.44,1487.47 1236.44,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1776.64,1487.47 1776.64,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2316.85,1487.47 2316.85,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  113.754,1452.34 147.339,1452.34 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  113.754,1233.91 147.339,1233.91 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  113.754,1015.48 147.339,1015.48 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  113.754,797.053 147.339,797.053 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  113.754,578.624 147.339,578.624 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  113.754,360.196 147.339,360.196 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  113.754,141.768 147.339,141.768 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 156.02, 1541.47)\" x=\"156.02\" y=\"1541.47\">0.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 696.228, 1541.47)\" x=\"696.228\" y=\"1541.47\">0.5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1236.44, 1541.47)\" x=\"1236.44\" y=\"1541.47\">1.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1776.64, 1541.47)\" x=\"1776.64\" y=\"1541.47\">1.5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 2316.85, 1541.47)\" x=\"2316.85\" y=\"1541.47\">2.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 89.7545, 1469.84)\" x=\"89.7545\" y=\"1469.84\">1</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 89.7545, 1251.41)\" x=\"89.7545\" y=\"1251.41\">2</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 89.7545, 1032.98)\" x=\"89.7545\" y=\"1032.98\">3</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 89.7545, 814.553)\" x=\"89.7545\" y=\"814.553\">4</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 89.7545, 596.124)\" x=\"89.7545\" y=\"596.124\">5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 89.7545, 377.696)\" x=\"89.7545\" y=\"377.696\">6</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 89.7545, 159.268)\" x=\"89.7545\" y=\"159.268\">7</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip4002)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  177.122,88.0053 372.243,349.524 489.503,485.413 588.645,589.342 696.34,691.94 795.626,777.881 902.07,861.655 1025.4,948.936 1135,1018.57 1231.1,1074.08 \n",
       "  1335.89,1129.23 1441.29,1179.57 1557.83,1229.79 1668.72,1272.81 1784.01,1313.09 1881.06,1343.81 1999.56,1377.78 2110.94,1406.48 2289.39,1446.71 \n",
       "  \"/>\n",
       "<polygon clip-path=\"url(#clip4000)\" points=\"\n",
       "1989.93,251.724 2280.76,251.724 2280.76,130.764 1989.93,130.764 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1989.93,251.724 2280.76,251.724 2280.76,130.764 1989.93,130.764 1989.93,251.724 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4000)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2013.93,191.244 2157.93,191.244 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip4000)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2181.93, 208.744)\" x=\"2181.93\" y=\"208.744\">y1</text>\n",
       "</g>\n",
       "</svg>\n"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(d) # uses the generic code!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few things to point out\n",
    "\n",
    "- Even if it worked for `StatsPlots`, our implementation is incomplete, as we haven’t fulfilled all of the requirements of a `Distribution`  \n",
    "- We also did not implement the `rand` function, which means we are breaking the implicit contract of the `Sampleable` abstract type  \n",
    "- It turns out that there is a better way to do this precise thing already built into `Distributions`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "typeof(d) = Truncated{Exponential{Float64},Continuous}\n"
     ]
    },
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip4400\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip4400)\" points=\"\n",
       "0,1600 2400,1600 2400,0 0,0 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip4401\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip4400)\" points=\"\n",
       "180.66,1487.47 2352.76,1487.47 2352.76,47.2441 180.66,47.2441 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip4402\">\n",
       "    <rect x=\"180\" y=\"47\" width=\"2173\" height=\"1441\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  239.598,1487.47 239.598,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  759.122,1487.47 759.122,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1278.65,1487.47 1278.65,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1798.17,1487.47 1798.17,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2317.69,1487.47 2317.69,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,1446.71 2352.76,1446.71 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,1098.64 2352.76,1098.64 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,750.569 2352.76,750.569 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,402.497 2352.76,402.497 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,54.4248 2352.76,54.4248 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1487.47 2352.76,1487.47 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1487.47 180.66,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  239.598,1487.47 239.598,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  759.122,1487.47 759.122,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1278.65,1487.47 1278.65,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1798.17,1487.47 1798.17,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2317.69,1487.47 2317.69,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1446.71 213.242,1446.71 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1098.64 213.242,1098.64 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,750.569 213.242,750.569 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,402.497 213.242,402.497 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,54.4248 213.242,54.4248 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 239.598, 1541.47)\" x=\"239.598\" y=\"1541.47\">0.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 759.122, 1541.47)\" x=\"759.122\" y=\"1541.47\">0.5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1278.65, 1541.47)\" x=\"1278.65\" y=\"1541.47\">1.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1798.17, 1541.47)\" x=\"1798.17\" y=\"1541.47\">1.5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 2317.69, 1541.47)\" x=\"2317.69\" y=\"1541.47\">2.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 1464.21)\" x=\"156.66\" y=\"1464.21\">0.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 1116.14)\" x=\"156.66\" y=\"1116.14\">2.5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 768.069)\" x=\"156.66\" y=\"768.069\">5.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 419.997)\" x=\"156.66\" y=\"419.997\">7.5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 71.9248)\" x=\"156.66\" y=\"71.9248\">10.0</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip4402)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  242.135,88.0053 244.672,120.776 247.208,152.756 249.745,183.965 252.282,214.421 254.819,244.143 257.355,273.147 259.892,301.453 271.62,423.694 283.348,532.888 \n",
       "  295.077,630.426 306.805,717.554 318.533,795.382 330.261,864.903 341.989,927.004 353.717,982.476 365.445,1032.03 377.174,1076.29 388.902,1115.83 400.63,1151.14 \n",
       "  424.086,1210.87 447.542,1258.53 475.735,1303.25 503.927,1337.34 532.12,1363.33 560.312,1383.15 607.985,1406.54 655.658,1421.32 759.23,1437.34 854.714,1442.97 \n",
       "  957.083,1445.32 1075.69,1446.27 1181.09,1446.55 1273.52,1446.65 1374.29,1446.69 1475.66,1446.7 1587.74,1446.71 1694.38,1446.71 1805.25,1446.71 1898.59,1446.71 \n",
       "  2012.55,1446.71 2119.67,1446.71 2291.28,1446.71 \n",
       "  \"/>\n",
       "<polygon clip-path=\"url(#clip4400)\" points=\"\n",
       "1989.93,251.724 2280.76,251.724 2280.76,130.764 1989.93,130.764 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1989.93,251.724 2280.76,251.724 2280.76,130.764 1989.93,130.764 1989.93,251.724 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4400)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2013.93,191.244 2157.93,191.244 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip4400)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2181.93, 208.744)\" x=\"2181.93\" y=\"208.744\">y1</text>\n",
       "</g>\n",
       "</svg>\n"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = Truncated(Exponential(0.1), 0.0, 2.0)\n",
    "@show typeof(d)\n",
    "plot(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the power of generic programming in general, and Julia in particular: you can combine and compose completely separate packages and code, as long as there is an agreement on abstract types and functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers and Algebraic Structures\n",
    "\n",
    "Define two binary functions,  $ + $ and $ \\cdot $, called addition and multiplication – although the operators can be applied to data structures much more abstract than a `Real`\n",
    "\n",
    "In mathematics, a [ring](https://en.wikipedia.org/wiki/Ring_%28mathematics%29) is a set with associated additive and multiplicative operators where\n",
    "\n",
    "> - the additive operator is associative and commutative  \n",
    "- the multiplicative operator is associative and distributive with respect to the additive operator  \n",
    "- there is an additive identity element,  denoted $ 0 $, such that $ a + 0 = a $ for any $ a $ in the set  \n",
    "- there is an additive inverse of each element, denoted $ -a $, such that $ a + (-a) = 0 $  \n",
    "- there is a multiplicative identity element, denoted $ 1 $, such that $ a \\cdot 1 = a = 1 \\cdot a $  \n",
    "- a total or partial ordering is **not** required (i.e., there does not need to be any meaningful $ < $ operator defined)  \n",
    "- a multiplicative inverse is **not** required  \n",
    "\n",
    "\n",
    "\n",
    "While this skips over some parts of the mathematical definition, this algebraic structure provides motivation for the abstract `Number` type in Julia\n",
    "\n",
    "> - **Remark:** We use the term “motivation” because they are not formally connected and the mapping is imperfect  \n",
    "- The main difficulty when dealing with numbers that can be concretely created on a computer is that the requirement that the operators are closed in the set are difficult to ensure (e.g. floating points have finite numbers of bits of information)  \n",
    "\n",
    "\n",
    "\n",
    "Let `typeof(a) = typeof(b) = T <: Number`, then under an informal definition of the **generic interface** for\n",
    "`Number`, the following must be defined\n",
    "\n",
    "> - the additive operator: `a + b`  \n",
    "- the multiplicative operator: `a * b`  \n",
    "- an additive inverse operator: `-a`  \n",
    "- an inverse operation for addition `a - b = a + (-b)`  \n",
    "- an additive identity: `zero(T)` or `zero(a)` for convenience  \n",
    "- a multiplicative identity: `one(T)` or `one(a)` for convenience  \n",
    "\n",
    "\n",
    "\n",
    "The core of generic programming is that, given the knowledge that a value is of type `Number`, we can design algorithms using any of these functions and not concern ourselves with the particular concrete type\n",
    "\n",
    "Furthermore, that generality in designing algorithms comes with no compromises on performance compared to carefully designed algorithms written for that particular type\n",
    "\n",
    "To demonstrate this for a complex number, where `Complex{Float64} <: Number`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "typeof(a) = Complex{Float64}\n",
      "typeof(a) <: Number = true\n",
      "a + b = 1.0 + 3.0im\n",
      "a * b = -2.0 + 2.0im\n",
      "-a = -1.0 - 1.0im\n",
      "a - b = 1.0 - 1.0im\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zero(a) = 0.0 + 0.0im\n",
      "one(a) = 1.0 + 0.0im\n"
     ]
    }
   ],
   "source": [
    "a = 1.0 + 1.0im\n",
    "b = 0.0 + 2.0im\n",
    "@show typeof(a)\n",
    "@show typeof(a) <: Number\n",
    "@show a + b\n",
    "@show a * b\n",
    "@show -a\n",
    "@show a - b\n",
    "@show zero(a)\n",
    "@show one(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And for an arbitrary precision integer where `BigInt <: Number`\n",
    "(i.e., a different type than the `Int64` you have worked with, but nevertheless a `Number`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "typeof(a) = BigInt\n",
      "typeof(a) <: Number = true\n",
      "a + b = 14\n",
      "a * b = 40\n",
      "-a = -10\n",
      "a - b = 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zero(a) = 0\n",
      "one(a) = 1\n"
     ]
    }
   ],
   "source": [
    "a = BigInt(10)\n",
    "b = BigInt(4)\n",
    "@show typeof(a)\n",
    "@show typeof(a) <: Number\n",
    "@show a + b\n",
    "@show a * b\n",
    "@show -a\n",
    "@show a - b\n",
    "@show zero(a)\n",
    "@show one(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complex Numbers and Composition of Generic Functions\n",
    "\n",
    "This allows us to showcase further how different generic packages compose – even if they are only loosely coupled through agreement on common generic interfaces\n",
    "\n",
    "The `Complex` numbers require some sort of storage for their underlying real and imaginary parts, which is itself left generic\n",
    "\n",
    "This data structure is defined to work with any type `<: Number`, and is parameterized (e.g. `Complex{Float64}` is a complex number storing the imaginary and real parts in `Float64`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(x, typeof(x)) = (4.0 + 1.0im, Complex{Float64})\n",
      "(xbig, typeof(xbig)) = "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4.0 + 1.0im, Complex{BigFloat})\n"
     ]
    }
   ],
   "source": [
    "x = 4.0 + 1.0im\n",
    "@show x, typeof(x)\n",
    "\n",
    "xbig = BigFloat(4.0) + 1.0im\n",
    "@show xbig, typeof(xbig);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The implementation of the `Complex` numbers use the underlying operations of\n",
    "storage type, so as long as `+`, `*` etc. are defined – as they should be\n",
    "for any `Number` – the complex operation can be defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "+(z::<b>Complex</b>, w::<b>Complex</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/complex.jl#L267\" target=\"_blank\">complex.jl:267</a>"
      ],
      "text/plain": [
       "+(z::Complex, w::Complex) in Base at complex.jl:267"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@which +(x,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following that link, the implementation of `+` for complex numbers is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```julia\n",
    "+(z::Complex, w::Complex) = Complex(real(z) + real(w), imag(z) + imag(w))\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`real(z)` and `imag(z)` returns the associated components of the complex number in the underlying storage type (e.g. `Float64` or `BigFloat`)\n",
    "\n",
    "The rest of the function has been carefully written to use functions defined for any `Number` (e.g. `+` but not `<`, since it is not part of the generic number interface)\n",
    "\n",
    "To follow another example , look at the implementation of `abs` specialized for complex numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "abs(z::<b>Complex</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/complex.jl#L260\" target=\"_blank\">complex.jl:260</a>"
      ],
      "text/plain": [
       "abs(z::Complex) in Base at complex.jl:260"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@which abs(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The source is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```julia\n",
    "abs(z::Complex)  = hypot(real(z), imag(z))\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, if you look at the generic function to get the hypotenuse, `hypot`, you will see that it has the function signature `hypot(x::T, y::T) where T<:Number`, and hence works for any `Number`\n",
    "\n",
    "That function, in turn, relies on the underlying `abs` for the type of `real(z)`\n",
    "\n",
    "This would dispatch to the appropriate `abs` for the type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "abs(x::<b>Float64</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/float.jl#L522\" target=\"_blank\">float.jl:522</a>"
      ],
      "text/plain": [
       "abs(x::Float64) in Base at float.jl:522"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@which abs(1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "abs(x::<b>Real</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/number.jl#L144\" target=\"_blank\">number.jl:144</a>"
      ],
      "text/plain": [
       "abs(x::Real) in Base at number.jl:144"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@which abs(BigFloat(1.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With implementations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```julia\n",
    "abs(x::Real) = ifelse(signbit(x), -x, x)\n",
    "abs(x::Float64) = abs_float(x)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a `Real` number (which we will discuss in the next section) the fallback implementation calls a function `signbit` to determine if it should flip the sign of the number\n",
    "\n",
    "The specialized version for `Float64 <: Real` calls a function called `abs_float` – which turns out to be a specialized implementation at the compiler level\n",
    "\n",
    "While we have not completely dissected the tree of function calls, at the bottom of the tree you will end at the most optimized version of the function for the underlying datatype\n",
    "\n",
    "Hopefully this showcases the power of generic programming:  with a well-designed set of abstract types and functions, the code can both be highly general and composable and still use the most efficient implementation possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reals and Algebraic Structures\n",
    "\n",
    "Thinking back to the mathematical motivation, a [field](https://en.wikipedia.org/wiki/Field_%28mathematics%29) is a `ring` with a few additional properties, among them\n",
    "\n",
    "> - a multiplicative inverse: $ a^{-1} $  \n",
    "- an inverse operation for multiplication: $ a / b = a \\cdot b^{-1} $  \n",
    "\n",
    "\n",
    "\n",
    "Furthermore, we will make it a [total ordered](https://en.wikipedia.org/wiki/Total_order#Strict_total_order) field with\n",
    "\n",
    "> - a total ordering binary operator: $ a < b $  \n",
    "\n",
    "\n",
    "\n",
    "This type gives some motivation for the operations and properties of the `Real` type\n",
    "\n",
    "Of course, `Complex{Float64} <: Number` but not `Real` – since the ordering is not defined for complex numbers in mathematics\n",
    "\n",
    "These operations are implemented in any subtype of `Real` through\n",
    "\n",
    "> - the multiplicative inverse: `inv(a)`  \n",
    "- the multiplicative inverse operation: `a / b = a * inv(b)`  \n",
    "- an ordering `a < b`  \n",
    "\n",
    "\n",
    "\n",
    "We have already shown these with the `Float64` and `BigFloat`\n",
    "\n",
    "To show this for the `Rational` number type, where `a // b` constructs a rational number $ \\frac{a}{b} $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "typeof(a) = Rational{Int64}\n",
      "typeof(a) <: Number = true\n",
      "typeof(a) <: Real = true\n",
      "inv(a) = "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10//1\n",
      "a / b = 3//20\n",
      "a < b = true\n"
     ]
    }
   ],
   "source": [
    "a = 1 // 10\n",
    "b = 4 // 6\n",
    "@show typeof(a)\n",
    "@show typeof(a) <: Number\n",
    "@show typeof(a) <: Real\n",
    "@show inv(a)\n",
    "@show a / b\n",
    "@show a < b;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark:** Here we see where and how the precise connection to the mathematics for number types breaks down for practical reasons, in particular\n",
    "\n",
    "> - `Integer` types (i.e., `Int64 <: Integer`) do not have a a multiplicative inverse with closure in the set  \n",
    "- However, it is necessary in practice for integer division to be defined, and return back a member of the `Real`’s  \n",
    "- This is called [type promotion](https://docs.julialang.org/en/v1/manual/conversion-and-promotion/#Promotion-1), where a type can be converted to another to ensure an operation is possible by direct conversion between types (i.e., it can be independent of the type hierarchy)  \n",
    "\n",
    "\n",
    "\n",
    "Do not think of the break in the connection between the underlying algebraic structures and the code as a failure of the language or design\n",
    "\n",
    "Rather, the underlying algorithms for use on a computer do not perfectly fit the algebraic structures in this instance\n",
    "\n",
    "Moving further down the tree of types provides more operations more directly tied to the computational implementation than abstract algebra\n",
    "\n",
    "For example, floating point numbers have a machine precision, below which numbers become indistinguishable due to lack of sufficient “bits” of information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Float64 <: AbstractFloat = true\n",
      "BigFloat <: AbstractFloat = true\n",
      "eps(Float64) = 2.220446049250313e-16\n",
      "eps(BigFloat) = 1.727233711018888925077270372560079914223200072887256277004740694033718360632485e-77\n"
     ]
    }
   ],
   "source": [
    "@show Float64 <: AbstractFloat\n",
    "@show BigFloat <: AbstractFloat\n",
    "@show eps(Float64)\n",
    "@show eps(BigFloat);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `isless` function also has multiple methods\n",
    "\n",
    "First let’s try with integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "isless(x::<b>Real</b>, y::<b>Real</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/operators.jl#L346\" target=\"_blank\">operators.jl:346</a>"
      ],
      "text/plain": [
       "isless(x::Real, y::Real) in Base at operators.jl:346"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@which isless(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we saw previously, the `Real` data type is an *abstract* type, and encompasses both floats and integers\n",
    "\n",
    "If we go to the provided link in the source, we see the entirety of the function is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```julia\n",
    "isless(x::Real, y::Real) = x<y\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is, for any values where `typeof(x) <: Real` and `typeof(y) <: Real`, the definition relies on `<`\n",
    "\n",
    "We know that `<` is defined for the types because it is part of the informal interface for the `Real` abstract type\n",
    "\n",
    "Note that this is not defined for `Number` because not all `Number` types have the `<` ordering operator defined (e.g. `Complex`)\n",
    "\n",
    "In order to generate fast code, the implementation details may define specialized versions of these operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "isless(x::<b>Float64</b>, y::<b>Float64</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/float.jl#L459\" target=\"_blank\">float.jl:459</a>"
      ],
      "text/plain": [
       "isless(x::Float64, y::Float64) in Base at float.jl:459"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isless(1.0, 2.0)  # applied to two floats\n",
    "@which isless(1.0, 2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the reason  `Float64 <: Real` calls this implementation rather than the one given above, is that `Float64 <: Real`, and Julia chooses the most specialized implementation for each function\n",
    "\n",
    "The specialized implementations are often more subtle than you may realize due to [floating point arithmetic](https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html), [underflow](https://en.wikipedia.org/wiki/Arithmetic_underflow), etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions, and Function-Like Types\n",
    "\n",
    "Another common example of the separation between data structures and algorithms is the use of functions\n",
    "\n",
    "Syntactically, a univariate “function” is any `f` that can call an argument `x` as `f(x)`\n",
    "\n",
    "For example, we can use a standard function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "quadgk(f, 0.0, 1.0) = (0.3333333333333333, 5.551115123125783e-17)\n"
     ]
    },
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip4800\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip4800)\" points=\"\n",
       "0,1600 2400,1600 2400,0 0,0 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip4801\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip4800)\" points=\"\n",
       "180.66,1487.47 2352.76,1487.47 2352.76,47.2441 180.66,47.2441 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip4802\">\n",
       "    <rect x=\"180\" y=\"47\" width=\"2173\" height=\"1441\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  242.135,1487.47 242.135,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  754.421,1487.47 754.421,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1266.71,1487.47 1266.71,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1778.99,1487.47 1778.99,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2291.28,1487.47 2291.28,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,1446.71 2352.76,1446.71 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,1107.04 2352.76,1107.04 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,767.359 2352.76,767.359 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,427.682 2352.76,427.682 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,88.0053 2352.76,88.0053 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1487.47 2352.76,1487.47 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1487.47 180.66,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  242.135,1487.47 242.135,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  754.421,1487.47 754.421,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1266.71,1487.47 1266.71,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1778.99,1487.47 1778.99,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2291.28,1487.47 2291.28,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1446.71 213.242,1446.71 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1107.04 213.242,1107.04 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,767.359 213.242,767.359 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,427.682 213.242,427.682 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,88.0053 213.242,88.0053 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 242.135, 1541.47)\" x=\"242.135\" y=\"1541.47\">0.00</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 754.421, 1541.47)\" x=\"754.421\" y=\"1541.47\">0.25</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1266.71, 1541.47)\" x=\"1266.71\" y=\"1541.47\">0.50</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1778.99, 1541.47)\" x=\"1778.99\" y=\"1541.47\">0.75</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 2291.28, 1541.47)\" x=\"2291.28\" y=\"1541.47\">1.00</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 1464.21)\" x=\"156.66\" y=\"1464.21\">0.00</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 1124.54)\" x=\"156.66\" y=\"1124.54\">0.25</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 784.859)\" x=\"156.66\" y=\"784.859\">0.50</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 445.182)\" x=\"156.66\" y=\"445.182\">0.75</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 105.505)\" x=\"156.66\" y=\"105.505\">1.00</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  242.135,1446.71 447.049,1433.13 651.964,1392.37 856.879,1324.43 1061.79,1229.32 1266.71,1107.04 1471.62,957.579 1676.54,780.946 1881.45,577.14 2086.37,346.16 \n",
       "  2291.28,88.0053 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4802)\" style=\"stroke:#e26f46; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  242.135,1446.71 447.049,1446.26 651.964,1443.09 856.879,1434.49 1061.79,1417.73 1266.71,1390.1 1471.62,1348.89 1676.54,1291.37 1881.45,1214.83 2086.37,1116.55 \n",
       "  2291.28,993.811 \n",
       "  \"/>\n",
       "<polygon clip-path=\"url(#clip4800)\" points=\"\n",
       "1949.78,312.204 2280.76,312.204 2280.76,130.764 1949.78,130.764 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1949.78,312.204 2280.76,312.204 2280.76,130.764 1949.78,130.764 1949.78,312.204 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1973.78,191.244 2117.78,191.244 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2141.78, 208.744)\" x=\"2141.78\" y=\"208.744\">f</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip4800)\" style=\"stroke:#e26f46; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1973.78,251.724 2117.78,251.724 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip4800)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2141.78, 269.224)\" x=\"2141.78\" y=\"269.224\">int_f</text>\n",
       "</g>\n",
       "</svg>\n"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using QuadGK\n",
    "f(x) = x^2\n",
    "@show quadgk(f, 0.0, 1.0)  # integral\n",
    "\n",
    "function plotfunctions(f)\n",
    "    intf(x) = quadgk(f, 0.0, x)[1]  # int_0^x f(x) dx\n",
    "\n",
    "    x = 0:0.1:1.0\n",
    "    f_x = f.(x)\n",
    "    plot(x, f_x, label=\"f\")\n",
    "    plot!(x, intf.(x), label=\"int_f\")\n",
    "end\n",
    "plotfunctions(f)  # call with our f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, univariate polynomials are another type of univariate function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p = Poly(2 - 5*x + 2*x^2)\n",
      "p(1.0) = -1.0\n"
     ]
    },
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip5200\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip5200)\" points=\"\n",
       "0,1600 2400,1600 2400,0 0,0 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip5201\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip5200)\" points=\"\n",
       "141.865,1487.47 2352.76,1487.47 2352.76,47.2441 141.865,47.2441 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip5202\">\n",
       "    <rect x=\"141\" y=\"47\" width=\"2212\" height=\"1441\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  204.437,1487.47 204.437,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  725.874,1487.47 725.874,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1247.31,1487.47 1247.31,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1768.75,1487.47 1768.75,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2290.18,1487.47 2290.18,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  141.865,1446.71 2352.76,1446.71 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  141.865,993.811 2352.76,993.811 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  141.865,540.908 2352.76,540.908 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  141.865,88.0053 2352.76,88.0053 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  141.865,1487.47 2352.76,1487.47 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  141.865,1487.47 141.865,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  204.437,1487.47 204.437,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  725.874,1487.47 725.874,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1247.31,1487.47 1247.31,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1768.75,1487.47 1768.75,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2290.18,1487.47 2290.18,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  141.865,1446.71 175.028,1446.71 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  141.865,993.811 175.028,993.811 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  141.865,540.908 175.028,540.908 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  141.865,88.0053 175.028,88.0053 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 204.437, 1541.47)\" x=\"204.437\" y=\"1541.47\">0.00</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 725.874, 1541.47)\" x=\"725.874\" y=\"1541.47\">0.25</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1247.31, 1541.47)\" x=\"1247.31\" y=\"1541.47\">0.50</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1768.75, 1541.47)\" x=\"1768.75\" y=\"1541.47\">0.75</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 2290.18, 1541.47)\" x=\"2290.18\" y=\"1541.47\">1.00</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 117.865, 1464.21)\" x=\"117.865\" y=\"1464.21\">-1</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 117.865, 1011.31)\" x=\"117.865\" y=\"1011.31\">0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 117.865, 558.408)\" x=\"117.865\" y=\"558.408\">1</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 117.865, 105.505)\" x=\"117.865\" y=\"105.505\">2</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  204.437,88.0053 413.012,305.399 621.586,504.676 830.161,685.837 1038.74,848.882 1247.31,993.811 1455.88,1120.62 1664.46,1229.32 1873.03,1319.9 2081.61,1392.37 \n",
       "  2290.18,1446.71 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5202)\" style=\"stroke:#e26f46; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  204.437,993.811 413.012,914.251 621.586,855.524 830.161,815.82 1038.74,793.326 1247.31,786.23 1455.88,792.722 1664.46,810.989 1873.03,839.22 2081.61,875.603 \n",
       "  2290.18,918.327 \n",
       "  \"/>\n",
       "<polygon clip-path=\"url(#clip5200)\" points=\"\n",
       "1949.78,312.204 2280.76,312.204 2280.76,130.764 1949.78,130.764 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1949.78,312.204 2280.76,312.204 2280.76,130.764 1949.78,130.764 1949.78,312.204 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1973.78,191.244 2117.78,191.244 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2141.78, 208.744)\" x=\"2141.78\" y=\"208.744\">f</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip5200)\" style=\"stroke:#e26f46; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1973.78,251.724 2117.78,251.724 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip5200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2141.78, 269.224)\" x=\"2141.78\" y=\"269.224\">int_f</text>\n",
       "</g>\n",
       "</svg>\n"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Polynomials\n",
    "p = Poly([2, -5, 2], :x)  # :x just gives a symbol for display\n",
    "@show p\n",
    "@show p(1.0) # call like a function\n",
    "\n",
    "plotfunctions(p)  # same generic function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, the result of interpolating data is also a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f_int(1.0) = 1.0\n"
     ]
    },
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip5600\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip5600)\" points=\"\n",
       "0,1600 2400,1600 2400,0 0,0 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip5601\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip5600)\" points=\"\n",
       "180.66,1487.47 2352.76,1487.47 2352.76,47.2441 180.66,47.2441 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip5602\">\n",
       "    <rect x=\"180\" y=\"47\" width=\"2173\" height=\"1441\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  242.135,1487.47 242.135,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  754.421,1487.47 754.421,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1266.71,1487.47 1266.71,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1778.99,1487.47 1778.99,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2291.28,1487.47 2291.28,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,1446.71 2352.76,1446.71 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,1107.04 2352.76,1107.04 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,767.359 2352.76,767.359 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,427.682 2352.76,427.682 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  180.66,88.0053 2352.76,88.0053 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1487.47 2352.76,1487.47 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1487.47 180.66,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  242.135,1487.47 242.135,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  754.421,1487.47 754.421,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1266.71,1487.47 1266.71,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1778.99,1487.47 1778.99,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2291.28,1487.47 2291.28,1465.87 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1446.71 213.242,1446.71 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,1107.04 213.242,1107.04 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,767.359 213.242,767.359 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,427.682 213.242,427.682 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  180.66,88.0053 213.242,88.0053 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 242.135, 1541.47)\" x=\"242.135\" y=\"1541.47\">0.00</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 754.421, 1541.47)\" x=\"754.421\" y=\"1541.47\">0.25</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1266.71, 1541.47)\" x=\"1266.71\" y=\"1541.47\">0.50</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1778.99, 1541.47)\" x=\"1778.99\" y=\"1541.47\">0.75</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 2291.28, 1541.47)\" x=\"2291.28\" y=\"1541.47\">1.00</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 1464.21)\" x=\"156.66\" y=\"1464.21\">0.00</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 1124.54)\" x=\"156.66\" y=\"1124.54\">0.25</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 784.859)\" x=\"156.66\" y=\"784.859\">0.50</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 445.182)\" x=\"156.66\" y=\"445.182\">0.75</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 156.66, 105.505)\" x=\"156.66\" y=\"105.505\">1.00</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  242.135,1446.71 447.049,1419.54 651.964,1392.37 856.879,1310.84 1061.79,1229.32 1266.71,1093.45 1471.62,957.579 1676.54,767.359 1881.45,577.14 2086.37,332.573 \n",
       "  2291.28,88.0053 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5602)\" style=\"stroke:#e26f46; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  242.135,1446.71 447.049,1445.35 651.964,1441.28 856.879,1431.77 1061.79,1414.1 1266.71,1385.57 1471.62,1343.45 1676.54,1285.03 1881.45,1207.58 2086.37,1108.4 \n",
       "  2291.28,984.753 \n",
       "  \"/>\n",
       "<polygon clip-path=\"url(#clip5600)\" points=\"\n",
       "1949.78,312.204 2280.76,312.204 2280.76,130.764 1949.78,130.764 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1949.78,312.204 2280.76,312.204 2280.76,130.764 1949.78,130.764 1949.78,312.204 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1973.78,191.244 2117.78,191.244 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2141.78, 208.744)\" x=\"2141.78\" y=\"208.744\">f</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip5600)\" style=\"stroke:#e26f46; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1973.78,251.724 2117.78,251.724 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip5600)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2141.78, 269.224)\" x=\"2141.78\" y=\"269.224\">int_f</text>\n",
       "</g>\n",
       "</svg>\n"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Interpolations\n",
    "x = 0.0:0.2:1.0\n",
    "f(x) = x^2\n",
    "f_int = LinearInterpolation(x, f.(x))  # interpolates the coarse grid\n",
    "@show f_int(1.0)  # call like a function\n",
    "\n",
    "plotfunctions(f_int)  # same generic function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the same generic `plotfunctions` could use any variable passed to it that “looks” like a function, i.e., can call `f(x)`\n",
    "\n",
    "This approach to design with types – generic, but without any specific type declarations – is called [duck typing](https://en.wikipedia.org/wiki/Duck_typing)\n",
    "\n",
    "If you need to make an existing type callable, see [Function Like Objects](https://docs.julialang.org/en/v1/manual/methods/#Function-like-objects-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Limitations of Dispatching on Abstract Types\n",
    "\n",
    "You will notice that types in Julia represent a tree with `Any` at the root\n",
    "\n",
    "The tree structure has worked well for the above examples, but it doesn’t allow us to associate multiple categorizations of types\n",
    "\n",
    "For example, a semi-group type would be useful for a writing generic code (e.g.\n",
    "continuous-time solutions for ODEs and matrix-free methods), but cannot be\n",
    "implemented rigorously since the `Matrix` type is a semi-group as well\n",
    "as an `AbstractArray`, but not all semi-groups are `AbstractArray` s\n",
    "\n",
    "The main way to implement this in a generic language is with a design approach called “traits”\n",
    "\n",
    "- See the [original discussion](https://github.com/JuliaLang/julia/issues/2345#issuecomment-54537633) and an [example of a package to facilitate the pattern](https://github.com/mauro3/SimpleTraits.jl)  \n",
    "- A complete description of the traits pattern as the natural evolution of Multiple Dispatch is given in this [blog post](https://white.ucc.asn.au/2018/10/03/Dispatch,-Traits-and-Metaprogramming-Over-Reflection.html)  "
   ]
  }
 ],
 "metadata": {
  "download_nb": 1,
  "download_nb_path": "https://lectures.quantecon.org/",
  "filename": "generic_programming.rst",
  "filename_with_path": "more_julia/generic_programming",
  "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"
  },
  "title": "Generic Programming"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}