languages/julia/julia-tutorial/source-notebooks/Julia-Tuor.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6c6629c6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A Julia Tour\n",
    "\n",
    "-------\n",
    "\n",
    "by Jonathan Maack"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02b19380",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Outline\n",
    "\n",
    "1. Why Julia?\n",
    "1. Basics\n",
    "1. Package Manager\n",
    "1. Types\n",
    "1. Structs\n",
    "1. Metaprogramming\n",
    "1. Other Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5cfc89f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Why Julia?\n",
    "\n",
    "\"Julia aims to create an unprecedented combination of ease-of-use, power, and efficiency in a single language.\" --Julia Documentation\n",
    "\n",
    "Feature Highlights:\n",
    "* Designed for scientific computing\n",
    "* Non-vectorized code is just as fast as vectorized code\n",
    "* Desgined for distributed and parallel computing\n",
    "* Call C/Fortran functions directly\n",
    "* Metaprogramming"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45bb0b76",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Basics: Outline\n",
    "\n",
    "* REPL (Read-Evaluate-Print-Loop)\n",
    "* Definining Functions\n",
    "* Using Installed Packages\n",
    "* Vectorizing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "414189d5",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## REPL (Read-Evaluate-Print-Loop)\n",
    "\n",
    "* Command line julia interface\n",
    "* Type the command `julia` in a terminal (assuming julia is in your path)\n",
    "* Basic way to interact with objects, packages and environments\n",
    "\n",
    "```\n",
    "jmaack-32918s:~ jmaack$ julia\n",
    "               _\n",
    "   _       _ _(_)_     |  Documentation: https://docs.julialang.org\n",
    "  (_)     | (_) (_)    |\n",
    "   _ _   _| |_  __ _   |  Type \"?\" for help, \"]?\" for Pkg help.\n",
    "  | | | | | | |/ _` |  |\n",
    "  | | |_| | | | (_| |  |  Version 1.6.1 (2021-04-23)\n",
    " _/ |\\__'_|_|_|\\__'_|  |  \n",
    "|__/                   |\n",
    "```\n",
    "```julia\n",
    "julia> 4 * pi^2 + sqrt(2)im\n",
    "39.47841760435743 + 1.4142135623730951im\n",
    "\n",
    "help?> Int\n",
    "search: Int Int8 Int64 Int32 Int16 Int128 Integer intersect intersect! InteractiveUtils InterruptException\n",
    "\n",
    "  Int64 <: Signed\n",
    "\n",
    "  64-bit signed integer type.\n",
    "\n",
    "julia> exit()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e65aac9",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## REPL (Read-Evaluate-Print-Loop)\n",
    "\n",
    "**NOTE:** When using the REPL, the result of the (last) expression is always printed. This is sometimes undesirable. We can supress printing by ending the last expression with a semicolon `;`. This is used throughout this presentation for appearance purposes. *Unless otherwise stated any semicolon in code is not needed.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d234a31",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Defining Functions\n",
    "\n",
    "Two ways to define functions\n",
    "* Standard way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "eaf6469e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "function my_function(x)\n",
    "    return x^2\n",
    "end;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4ccc48e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Short form way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9887ee09",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_func(x) = x^2;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a48b3abb",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Defining Functions\n",
    "\n",
    "It is also possible to define anonymous functions (and save pointers to them):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e1e247ce",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f = (x)->x^2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9d729c75",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_function(pi) = 9.869604401089358\n",
      "my_func(pi) = 9.869604401089358\n",
      "f(pi) = 9.869604401089358\n"
     ]
    }
   ],
   "source": [
    "@show my_function(pi)\n",
    "@show my_func(pi)\n",
    "@show f(pi);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9568c0f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**NOTE:** Julia uses the standard control flow keywords such as `for`, `while`, `if`, `elseif`, `else`. See the [Control Flow](https://docs.julialang.org/en/v1/manual/control-flow/) section of the Julia documentation for more details. Obviously, these are helpful in writing functions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3390cac9",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using Installed Packages\n",
    "\n",
    "Packages can be accessed in two ways:\n",
    "* `import` statement -- makes all module attributes (i.e. functions and types) available by prefixing the module name followed by a dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ee52cb5a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5259355140049331"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = rand(5)\n",
    "import Statistics\n",
    "Statistics.mean(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c02712d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `using` statement -- everything exported by the module is directly accessible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "29f8e291",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5259355140049331"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Statistics\n",
    "mean(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdd7efcd",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using Installed Packages\n",
    "\n",
    "Any attribute that is not exported by the module can still be accessed by prefixing the module name followed by a dot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fc948255",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Float64}:\n",
       " 0.2707024204296571\n",
       " 0.39735474630786594\n",
       " 0.9834902614522977\n",
       " 0.06595428121890445\n",
       " 0.9121758606159401"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Statistics._conj(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79352171",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**NOTE:** Like in python, there are no private attributes. Users may access anything created by a module. Package authors can suggest attributes that users should not use by not exporting them or with naming conventions (e.g. prefixing `_` to any name that is internal only)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "877f156a",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using Installed Packages\n",
    "\n",
    "Julia 1.6 introduced the \"pythonic\" import syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b34a80ae",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5259355140049331"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Statistics as Stats\n",
    "Stats.mean(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90da9df2",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In older Julia versions, we can declare a constant for our packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "687c0bb1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5259355140049331"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Statistics\n",
    "const St = Statistics\n",
    "St.mean(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "014ff529",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**ADVICE:** When writing Julia code, use `import` rather than `using`. This makes code easier to follow as well as giving hints on where to look for documentation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63a866ed",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Vectorizing\n",
    "\n",
    "Julia uses the MATLAB dot syntax to operate component-wise on arrays (i.e. vectors and matrices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "278b1ab4",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.27666160740434603\n",
       " 0.033048733639363365\n",
       " 0.14787972327087262"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = rand(3)\n",
    "y = rand(3)\n",
    "(x.*y).^2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2780987b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Julia also extends this syntax to **ANY** function that operates on vector elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0cf59539",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 5.991513272420046\n",
       " 5.91775347689596\n",
       " 5.975237702328327"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number_op(x) = x + 5\n",
    "number_op.(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86760a5c",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Vectorizing\n",
    "\n",
    "In Julia, vectorizing is done for convenience rather than performance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e2701dfe",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "function my_mult_for(x,y)\n",
    "    z = zeros(length(x))\n",
    "    for k in length(x)\n",
    "        z[k] = x[k] * y[k]\n",
    "    end\n",
    "    return z\n",
    "end\n",
    "\n",
    "function my_mult_vect(x,y)\n",
    "    return x .* y\n",
    "end;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7a97d688",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.070129 seconds (156.51 k allocations: 7.860 MiB, 99.97% compilation time)\n",
      "  0.009471 seconds (14.73 k allocations: 741.457 KiB, 99.84% compilation time)\n"
     ]
    }
   ],
   "source": [
    "# This forces Julia to compile the function definitions\n",
    "# so that the timing results in the next cell are correct\n",
    "x = rand(2)\n",
    "y = rand(2)\n",
    "@time my_mult_vect(x,y)\n",
    "@time my_mult_for(x,y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a0cae620",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.000077 seconds (2 allocations: 78.172 KiB)\n",
      "  0.000050 seconds (2 allocations: 78.172 KiB)\n"
     ]
    }
   ],
   "source": [
    "x = rand(10000)\n",
    "y = rand(10000)\n",
    "@time my_mult_vect(x,y)\n",
    "@time my_mult_for(x,y);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95933f24",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Package Manager: Outline\n",
    "\n",
    "* Managing Packages (REPL)\n",
    "* Managing Packages (Scripts)\n",
    "* Environments\n",
    "* Activating Environments\n",
    "* Copying Environments\n",
    "* Environment Layering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1ca148d",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Managing Packages (REPL)\n",
    "\n",
    "Open the REPL and hit the `[` key to enter package management mode. From here we can add or remove packages:\n",
    "```julia\n",
    "(@v1.6) pkg> add Compat\n",
    "   Resolving package versions...\n",
    "    Updating `~/.julia/environments/v1.6/Project.toml`\n",
    "  [34da2185] + Compat v3.31.0\n",
    "    Updating `~/.julia/environments/v1.6/Manifest.toml`\n",
    "  [34da2185] + Compat v3.31.0\n",
    "  [8bb1440f] + DelimitedFiles\n",
    "  [8ba89e20] + Distributed\n",
    "  [1a1011a3] + SharedArrays\n",
    "  [2f01184e] + SparseArrays\n",
    "  [10745b16] + Statistics\n",
    "\n",
    "(@v1.6) pkg> rm Compat\n",
    "    Updating `~/.julia/environments/v1.6/Project.toml`\n",
    "  [34da2185] - Compat v3.31.0\n",
    "    Updating `~/.julia/environments/v1.6/Manifest.toml`\n",
    "  [34da2185] - Compat v3.31.0\n",
    "  [8bb1440f] - DelimitedFiles\n",
    "  [8ba89e20] - Distributed\n",
    "  [1a1011a3] - SharedArrays\n",
    "  [2f01184e] - SparseArrays\n",
    "  [10745b16] - Statistics\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6489d8e9",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Managing Packages (REPL)\n",
    "\n",
    "We can also print out what packages are available\n",
    "```julia\n",
    "(@v1.6) pkg> st\n",
    "      Status `~/.julia/environments/v1.6/Project.toml`\n",
    "  [7073ff75] IJulia v1.23.2\n",
    "  [438e738f] PyCall v1.92.3\n",
    "```\n",
    "or update the packages\n",
    "```julia\n",
    "(@v1.6) pkg> up\n",
    "    Updating registry at `~/.julia/registries/General`\n",
    "    Updating git-repo `https://github.com/JuliaRegistries/General.git`\n",
    "  No Changes to `~/.julia/environments/v1.6/Project.toml`\n",
    "  No Changes to `~/.julia/environments/v1.6/Manifest.toml`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3962bc50",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Managing Packages (Scripts)\n",
    "\n",
    "Package management mode in the REPL is actually just a convenient interface to the Julia package [Pkg.jl](https://pkgdocs.julialang.org/stable/) which is part of the Julia standard library.\n",
    "\n",
    "All package mode commands are functions in Pkg.jl:\n",
    "```julia\n",
    "import Pkg; Pkg.add(\"Compat\"); Pkg.rm(\"Compat\")\n",
    "\n",
    "    Updating registry at `~/.julia/registries/General`\n",
    "    Updating git-repo `https://github.com/JuliaRegistries/General.git`\n",
    "   Resolving package versions...\n",
    "    Updating `~/.julia/environments/v1.6/Project.toml`\n",
    "  [34da2185] + Compat v3.31.0\n",
    "    Updating `~/.julia/environments/v1.6/Manifest.toml`\n",
    "  [34da2185] + Compat v3.31.0\n",
    "  [8bb1440f] + DelimitedFiles\n",
    "  [8ba89e20] + Distributed\n",
    "  [1a1011a3] + SharedArrays\n",
    "  [2f01184e] + SparseArrays\n",
    "  [10745b16] + Statistics\n",
    "    Updating `~/.julia/environments/v1.6/Project.toml`\n",
    "  [34da2185] - Compat v3.31.0\n",
    "    Updating `~/.julia/environments/v1.6/Manifest.toml`\n",
    "  [34da2185] - Compat v3.31.0\n",
    "  [8bb1440f] - DelimitedFiles\n",
    "  [8ba89e20] - Distributed\n",
    "  [1a1011a3] - SharedArrays\n",
    "  [2f01184e] - SparseArrays\n",
    "  [10745b16] - Statistics\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1c4eac3",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Managing Packages (Scripts)\n",
    "\n",
    "```julia\n",
    "Pkg.status(); Pkg.update()\n",
    "\n",
    "      Status `~/.julia/environments/v1.6/Project.toml`\n",
    "  [7073ff75] IJulia v1.23.2\n",
    "  [438e738f] PyCall v1.92.3\n",
    "    Updating registry at `~/.julia/registries/General`\n",
    "    Updating git-repo `https://github.com/JuliaRegistries/General.git`\n",
    "  No Changes to `~/.julia/environments/v1.6/Project.toml`\n",
    "  No Changes to `~/.julia/environments/v1.6/Manifest.toml`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f981e6b4",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**WARNING:** If you want to use Julia within Jupyter notebook, some of the package management stuff (like adding new packages) does not work well. It is best to add/remove/update either with a script or using the REPL."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8231068a",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Environments\n",
    "\n",
    "Environments allow us to install different versions of packages for use with different projects. Very similar to python virtual environments or conda environments.\n",
    "\n",
    "```julia\n",
    "Pkg.activate(\"env-one\"); Pkg.status()\n",
    "\n",
    "  Activating environment at `~/HPC_Apps/julia-tutorial/env-one/Project.toml`\n",
    "      Status `~/HPC_Apps/julia-tutorial/env-one/Project.toml`\n",
    "  [91a5bcdd] Plots v1.13.1\n",
    "```\n",
    "\n",
    "```julia\n",
    "Pkg.activate(\"env-two\"); Pkg.status()\n",
    "\n",
    "  Activating environment at `~/HPC_Apps/julia-tutorial/env-two/Project.toml`\n",
    "      Status `~/HPC_Apps/julia-tutorial/env-two/Project.toml`\n",
    "  [91a5bcdd] Plots v1.16.6\n",
    "```\n",
    "\n",
    "The environment names are given by the directory in which they reside. The explicitly added packages are given in the `Project.toml` file. The entire environment with all the required dependencies (down to specific commits) are in the `Manifest.toml` file."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a77f0e0",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Activating Environments\n",
    "\n",
    "There are 3 ways to activate an environment:\n",
    "* Using the `Pkg.activate` function:\n",
    "```julia\n",
    "Pkg.activate(\"path/to/environment/\")\n",
    "```\n",
    "* Within package management mode with the `activate` command:\n",
    "```julia\n",
    "activate path/to/environment\n",
    "```\n",
    "* From the command line with the `--project` option:\n",
    "```shell\n",
    "julia --project=<path/to/environment>\n",
    "```\n",
    "\n",
    "The first 2 can also be used to **create** new environments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a562dc35",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Copying Environments\n",
    "\n",
    "To copy an environment, all you need is the `Project.toml` file. Put it in the desired directory and activate that environment. Finally, in package management mode, use the `instantiate` command:\n",
    "\n",
    "```julia\n",
    "(fake-env) pkg> st\n",
    "      Status `~/fake-env/Project.toml`\n",
    "→ [da04e1cc] MPI v0.18.1\n",
    "        Info packages marked with → not downloaded, use `instantiate` to download\n",
    "\n",
    "(fake-env) pkg> instantiate\n",
    "   Installed MPI ─ v0.18.1\n",
    "    Building MPI → `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/494d99052881a83f36f5ef08b23de07cc7c03a96/build.log`\n",
    "Precompiling project...\n",
    "  1 dependency successfully precompiled in 2 seconds (11 already precompiled)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c39dbf9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**NOTE:** Alternatively, you can use the `Pkg.instantiate` function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a07622ed",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**NOTE:** If you need to exactly copy an environment exactly copy both the `Project.toml` and `Manifest.toml` files into the desired directory and use the `instantiate` command."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "841e7172",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Environment Layering\n",
    "\n",
    "Julia environments layer so that packages from more than just the top layer environment can be imported. This allows us to have access to debugging and development tools without putting them in whatever environment were working on. This is a major difference from conda environments.\n",
    "\n",
    "```julia\n",
    "Pkg.status()\n",
    "      Status `~/HPC_Apps/julia-tutorial/env-one/Project.toml`\n",
    "  [91a5bcdd] Plots v1.13.1\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "42ed10f9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import BenchmarkTools as BT # THIS IS NOT IN OUR TOP ENVIRONMENT!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "255a0a28",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "When loading a package, Julia has a hierarchy of environments that it checks for the package. Julia loads the first version of the package it encounters in this hierarchy.  The environment hierarchy can be altered by the [`JULIA_LOAD_PATH`](https://docs.julialang.org/en/v1/manual/environment-variables/) environment variable.\n",
    "\n",
    "These environment stacks are discussed more in the [Environments](https://docs.julialang.org/en/v1/manual/code-loading/#Environments) subsection of the Code Loading part of the Julia Manual."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfac99f0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Types: Outline\n",
    "\n",
    "* Type Hierarchy\n",
    "* Multiple Dispatch"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20d93d1c",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Type Hierarchy\n",
    "\n",
    "In Julia everything has a type. We can access an object's type with the `typeof` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "688d9d76",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(7.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d7e8ecc",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Even types have a type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bb06463d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataType"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(Float64)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99009f5e",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Type Hierarchy\n",
    "\n",
    "Julia also has a type hierarchy. There are subtypes and supertypes. We can access explore these with the functions `subtypes` and `supertype`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f12cf4c8",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Type[]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subtypes(Float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c59a7e07",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AbstractFloat"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "supertype(Float64)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a8c55a5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`Float64` has no subtypes because it is a **Concrete Type**. All the supertypes are an **Abstract Type**.  Only Concrete Types can actually exist."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e590e32",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Type Hierarchy\n",
    "\n",
    "Every type has **only one** immediate supertype. However, each supertype has a supertype. We can get the whole chain with the `supertypes` (plural) function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "aecb264c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Float64, AbstractFloat, Real, Number, Any)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "supertypes(Float64)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e444212",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us see all the floating point types available in Julia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cb8632f8",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{Any}:\n",
       " BigFloat\n",
       " Float16\n",
       " Float32\n",
       " Float64"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subtypes(AbstractFloat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c02625c7",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Type Hierarchy\n",
    "\n",
    "We can test whether or not a type is a subtype of something with the `<:` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b74676bd",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Float64 <: AbstractFloat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0d35a172",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Float64 <: Float64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ac49faf8",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Int <: AbstractFloat"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3964233a",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Type Hierarchy\n",
    "\n",
    "**WARNING:** Subtypes and supertypes get complicated when dealing with containers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "87753c63",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Float64 <: Real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7b104814",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector{Float64} <: Vector{Real}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2e8cea53",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector{Float64} <: Vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa77a893",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Type Hierarchy\n",
    "\n",
    "We can use this to write functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0ff0fa3b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real!\n",
      "my_abs_sub(-5) = 5\n",
      "Real!\n",
      "my_abs_sub(-5.0) = 5.0\n",
      "Complex!\n",
      "my_abs_sub(-1 + 2im) = 2.23606797749979\n"
     ]
    }
   ],
   "source": [
    "function my_abs_sub(x)\n",
    "    if typeof(x) <: Complex\n",
    "        println(\"Complex!\")\n",
    "        return sqrt(x.re^2 + x.im^2)\n",
    "    elseif typeof(x) <: Real\n",
    "        println(\"Real!\")\n",
    "        return x < 0 ? -x : x\n",
    "    else\n",
    "        error(\"Not a number!\")\n",
    "    end\n",
    "end\n",
    "@show my_abs_sub(-5)\n",
    "@show my_abs_sub(-5.0)\n",
    "@show my_abs_sub(-1 + 2im);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac870eae",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Multiple Dispatch\n",
    "\n",
    "A more Julia way of doing this is to write the typing information directly into the function definition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d71559c3",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiple Dispatch Real!\n",
      "my_abs_md(-5) = 5\n",
      "Multiple Dispatch Complex!\n",
      "my_abs_md(-1 + 2im) = 2.23606797749979\n"
     ]
    }
   ],
   "source": [
    "function my_abs_md(x::Real)\n",
    "    println(\"Multiple Dispatch Real!\")\n",
    "    return x < 0 ? -x : x\n",
    "end\n",
    "function my_abs_md(x::Complex)\n",
    "    println(\"Multiple Dispatch Complex!\")\n",
    "    return sqrt(x.re^2 + x.im^2)\n",
    "end\n",
    "@show my_abs_md(-5)\n",
    "@show my_abs_md(-1 + 2im);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b39c19d7",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Notice that the functions have the same name but the correct one is executed based on the type of the argument. This is called **Multiple Dispatch**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "392d4c9e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**ADVICE:** Add typing information for any function you are likely to use a lot. There are two reasons\n",
    "1. Type information is used by the Julia compiler to make code more efficient\n",
    "2. Type information is a fast and easy way to document your code and catch bugs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1cc686f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Structs: Outline\n",
    "\n",
    "* Defining Structs\n",
    "* Mutable Structs\n",
    "* Parametric Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e80810c1",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Defining Structs\n",
    "\n",
    "Julia allows us to define our own (composite) types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "81fed228",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(1.0, 2.0)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct Point\n",
    "    x::Float64\n",
    "    y::Float64\n",
    "end\n",
    "p0 = Point(0, 0)\n",
    "p1 = Point(1.0, 2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f5d51c2",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can define functions with this type as the argument now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a0ef574a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.23606797749979"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function distance(p::Point, q::Point)\n",
    "    return sqrt((p.x - q.x)^2 + (p.y - q.y)^2)\n",
    "end\n",
    "distance(p0, p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80932e50",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Defining Structs\n",
    "\n",
    "We can build structs with other structs as components:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "715a2017",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Circle(Point(1.0, 2.0), 5.0)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct Circle\n",
    "    center::Point\n",
    "    radius::Float64\n",
    "end\n",
    "\n",
    "my_circle = Circle(p1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5228b389",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is_in(p0, my_circle) = true\n",
      "is_in(Point(100, 0), my_circle) = false\n"
     ]
    }
   ],
   "source": [
    "function is_in(p::Point, c::Circle)\n",
    "    return distance(p, c.center) < c.radius\n",
    "end\n",
    "@show is_in(p0, my_circle)\n",
    "@show is_in(Point(100,0), my_circle);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b8d87ae",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Mutable Structs\n",
    "\n",
    "What if we want to change the radius of the circle?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "4e5d1d80",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "setfield!: immutable struct of type Circle cannot be changed",
     "output_type": "error",
     "traceback": [
      "setfield!: immutable struct of type Circle cannot be changed",
      "",
      "Stacktrace:",
      " [1] setproperty!(x::Circle, f::Symbol, v::Float64)",
      "   @ Base ./Base.jl:39",
      " [2] top-level scope",
      "   @ In[34]:1",
      " [3] eval",
      "   @ ./boot.jl:368 [inlined]",
      " [4] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base ./loading.jl:1428"
     ]
    }
   ],
   "source": [
    "my_circle.radius = 10.0 # Causes an error!!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9ad71d1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Structs are immutable (cannot be changed) by default in Julia. This allows for some optimizations behind the scenes and most of the time we do not need to change the values in a Struct."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c096bbc0",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Mutable Structs\n",
    "\n",
    "If we need to change fields in a struct, we add the `mutable` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f492b7eb",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_mutable_circle = MutableCircle(Point(1.0, 2.0), 5.0)\n",
      "my_mutable_circle = MutableCircle(Point(1.0, 2.0), 10.0)\n"
     ]
    }
   ],
   "source": [
    "mutable struct MutableCircle\n",
    "    center::Point\n",
    "    radius::Float64\n",
    "end\n",
    "my_mutable_circle = MutableCircle(p1, 5.0)\n",
    "@show my_mutable_circle\n",
    "my_mutable_circle.radius = 10.0\n",
    "@show my_mutable_circle;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b64b870",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Parametric Types\n",
    "\n",
    "Let us go back to our Point type:\n",
    "\n",
    "```julia\n",
    "struct Point\n",
    "    x::Float64\n",
    "    y::Float64\n",
    "end\n",
    "```\n",
    "\n",
    "We locked in the types in the fields of this struct. What if we want to a `Point` struct with a different type? Such as an `Int`. We use a **Parametric Type**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d630bfc3",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Parametric Types\n",
    "\n",
    "We define a Parametric Type in the following way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2647c4e6",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "struct ParametricPoint{R <: Real}\n",
    "    x::R\n",
    "    y::R\n",
    "end\n",
    "\n",
    "function distance(p::ParametricPoint{<:Real},\n",
    "        q::ParametricPoint{<:Real})\n",
    "    return sqrt((p.x - q.x)^2 + (p.y - q.y)^2)\n",
    "end;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "1b48b3d0",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "typeof(p0) = ParametricPoint{Int64}\n",
      "typeof(p1) = ParametricPoint{Float64}\n",
      "distance(p0, p1) = 1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "p0 = ParametricPoint(1, -1)\n",
    "@show typeof(p0)\n",
    "p1 = ParametricPoint(2.0, 0.0)\n",
    "@show typeof(p1)\n",
    "@show distance(p0,p1);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d20457e7",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Metaprogramming: Outline\n",
    "\n",
    "* How Julia Code is Executed\n",
    "* Expressions\n",
    "* Macros"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8bb596c",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## How Julia Code is Executed\n",
    "\n",
    "At a very high level, Julia code is executed in two phases:\n",
    "1. Parsing a string and turning it into an expression\n",
    "2. Evaluating that expression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e20b34d",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Expressions\n",
    "\n",
    "Julia code is parsed and turned into expressions. These expressions are themselves Julia data structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e700c166",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(z ^ 2 + 1)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = Meta.parse(\"z^2 + 1\")\n",
    "expr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cee105b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "While the expression prints as a human readable mathematical expression, it is actually a tree:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "34d9739f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol call\n",
      "  args: Array{Any}((3,))\n",
      "    1: Symbol +\n",
      "    2: Expr\n",
      "      head: Symbol call\n",
      "      args: Array{Any}((3,))\n",
      "        1: Symbol ^\n",
      "        2: Symbol z\n",
      "        3: Int64 2\n",
      "    3: Int64 1\n"
     ]
    }
   ],
   "source": [
    "dump(expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7a34877",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Expressions\n",
    "\n",
    "Since this is a data structure, we can change the expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "8443846f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(z * 2 - 1)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.args[1] = :-\n",
    "expr.args[2].args[1] = :*\n",
    "expr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66c2caa5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Then evaluate it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "e9d472ea",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eval(expr) = 5\n",
      "eval(expr) = 4.0\n"
     ]
    }
   ],
   "source": [
    "z = 3\n",
    "@show eval(expr)\n",
    "z = 2.5\n",
    "@show eval(expr);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "324ccf2f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Note we gave `z` a value **after** we wrote the expression."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04b57fc2",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "A macro is a special function that takes expressions, symbols and literal values as arguments and returns an expression. The biggest difference between a macro and a normal function is that a macro is executed during the **parse** phase. This means that in a macro we have access to the expression!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e26caa7a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let's take a look at the `@assert` macro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "ca4b42a6",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "AssertionError: x == y",
     "output_type": "error",
     "traceback": [
      "AssertionError: x == y",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[42]:2",
      " [2] eval",
      "   @ ./boot.jl:368 [inlined]",
      " [3] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base ./loading.jl:1428"
     ]
    }
   ],
   "source": [
    "x = 5; y = 4;\n",
    "@assert x == y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab2b7a7b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The error contains the expression that caused the error! This is not possible to do with a function because that expression is not available at runtime."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da4705f7",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "How do we write macros? More or less like we write functions but using the `macro` keyword instead of the `function` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "869809fc",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@fadd (macro with 1 method)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macro fadd(name::Symbol, f::Symbol, g::Symbol, nargs::Int)\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "    quote\n",
    "        $(esc(name))($(x...)) = $(esc(f))($(x...)) + $(esc(g))($(x...))\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b35231c8",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This macro takes two functions and creates an expression that for a function that computes the sum of the two. It is actually generating code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "c17a816c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p(pi) + q(pi) = 11.012830091668627\n",
      "h(pi) = 11.012830091668627\n"
     ]
    }
   ],
   "source": [
    "p(x) = x^2\n",
    "q(x) = (2x + 5) / x^2\n",
    "@fadd(h, p, q, 1)\n",
    "@show p(pi) + q(pi)\n",
    "@show h(pi);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb81effd",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "We can look at the expression that the macro generates with the macro `@macroexpand`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "a4600bd9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    \u001b[90m#= In[43]:4 =#\u001b[39m\n",
       "    h(var\"#81###313\") = begin\n",
       "            \u001b[90m#= In[43]:4 =#\u001b[39m\n",
       "            p(var\"#81###313\") + q(var\"#81###313\")\n",
       "        end\n",
       "end"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@macroexpand(@fadd(h, p, q, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f527f69c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ignoring all the stuff with `#` symbols we can see that the expression returned by the macro looks more or less like a function definition."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98f3f7ed",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "Having seen how this works let's unpack the macro definition a bit more. For context, here's the whole definition again:\n",
    "\n",
    "```julia\n",
    "macro fadd(name::Symbol, f::Symbol, g::Symbol, nargs::Int)\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "    quote\n",
    "        $(esc(name))($(x...)) = $(esc(f))($(x...)) + $(esc(g))($(x...))\n",
    "    end\n",
    "end\n",
    "```\n",
    "\n",
    "We'll unpack it one line at a time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1343190d",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "Having seen how this works let's unpack the macro definition a bit more. For context, here's the whole definition again:\n",
    "\n",
    "```julia\n",
    "macro fadd(name::Symbol, f::Symbol, g::Symbol, nargs::Int)\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "    quote\n",
    "        $(esc(name))($(x...)) = $(esc(f))($(x...)) + $(esc(g))($(x...))\n",
    "    end\n",
    "end\n",
    "```\n",
    "\n",
    "First Line:\n",
    "\n",
    "```julia\n",
    "macro fadd(name::Symbol, f::Symbol, g::Symbol, nargs::Int)\n",
    "    ...\n",
    "end\n",
    "```\n",
    "\n",
    "The macro definition looks a lot like a function definition but with `macro` instead of `function`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e864703a",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "Having seen how this works let's unpack the macro definition a bit more. For context, here's the whole definition again:\n",
    "\n",
    "```julia\n",
    "macro fadd(name::Symbol, f::Symbol, g::Symbol, nargs::Int)\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "    quote\n",
    "        $(esc(name))($(x...)) = $(esc(f))($(x...)) + $(esc(g))($(x...))\n",
    "    end\n",
    "end\n",
    "```\n",
    "\n",
    "Second Line:\n",
    "\n",
    "```julia\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "```\n",
    "\n",
    "Here we create a vector of symbols of size `nargs`. The `gensym` function generates a symbol for a variable that is guaranteed not to clash with existing variables.  These symbols will be the arguments of our new function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7afea39b",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "Having seen how this works let's unpack the macro definition a bit more. For context, here's the whole definition again:\n",
    "\n",
    "```julia\n",
    "macro fadd(name::Symbol, f::Symbol, g::Symbol, nargs::Int)\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "    quote\n",
    "        $(esc(name))($(x...)) = $(esc(f))($(x...)) + $(esc(g))($(x...))\n",
    "    end\n",
    "end\n",
    "```\n",
    "\n",
    "Third Line:\n",
    "\n",
    "```julia\n",
    "    quote\n",
    "        # expression here\n",
    "    end\n",
    "```\n",
    "\n",
    "This is an easy way to generate an expression. The contents of this block is the expression returned by the macro."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f394031b",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "Having seen how this works let's unpack the macro definition a bit more. For context, here's the whole definition again:\n",
    "\n",
    "```julia\n",
    "macro fadd(name::Symbol, f::Symbol, g::Symbol, nargs::Int)\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "    quote\n",
    "        $(esc(name))($(x...)) = $(esc(f))($(x...)) + $(esc(g))($(x...))\n",
    "    end\n",
    "end\n",
    "```\n",
    "\n",
    "Fourth Line:\n",
    "\n",
    "```julia\n",
    "        $(esc(name))($(x...)) = $(esc(f))($(x...)) + $(esc(g))($(x...))\n",
    "```\n",
    "\n",
    "This is the meat of the macro and it may seem a bit much at first.  However, each term is essentially the same. So let's just focus on the left hand side of the equality."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a284db7",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "```julia\n",
    "        $(esc(name))($(x...))\n",
    "```\n",
    "\n",
    "* The `name` variable is local to the macro. It's value is what we want to put into the expression. So we **interpolate** it into the expression using `$`. \n",
    "* However, we want that symbol to be evaluated in the context in which the macro was called. So we tell Julia to leave the value as is with the `esc` function.\n",
    "* Without the call to `esc`, Julia will assume that the variable is local and needs to be renamed with `gensym` transformed so that it will not clash with other variables.\n",
    "* Finally, we want to interpolate the contents of the vector `x` into the expression. This is done with the **splat operator** `...` in conjunction with `$`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9580f281",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "Why can't we just write a function to do this? Let's try:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe36700",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```julia\n",
    "function fadd(name, f::Function, g::Function, nargs::Int)\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "    [WHAT HERE?](x...) = f(x...) + g(x...)\n",
    "    return [WHAT TO RETURN?]\n",
    "end\n",
    "```\n",
    "There are a couple problems here:\n",
    "1. What do we put for the function name? We want the **value** of the argument name. If we just put `name` we would end up with a function called name.\n",
    "1. What do we return? Even if we knew what to name the function, that name is only bound to the function **in our current scope**--the function `fadd`. Once we return from `fadd`, the name is no longer bound to this function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6ef2481",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "If we do not care about creating function names, we could construct and return an anonymous function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "b902acbe",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.012830091668627"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function fadd(f::Function, g::Function, nargs::Int)\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "    return (x...)->(f(x...) + g(x...))\n",
    "end\n",
    "h1 = fadd(p,q,1)\n",
    "h1(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f17779bd",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This gets us pretty close to the same functionality since we could assign the function pointer to any valid variable name."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5081654e",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Macros\n",
    "\n",
    "However, we did not maximize the value of the macro. We can actually generate documentation for our function as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "85a18fd8",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "macro fadd(name::Symbol, f::Symbol, g::Symbol, nargs::Int)\n",
    "    x = [gensym() for _ in 1:nargs]\n",
    "    local help = \"Functions $f and $g added together. Created with the `@fadd` macro!\"\n",
    "    quote\n",
    "        @doc string($help)\n",
    "        $(esc(name))($(x...)) = $(esc(f))($(x...)) + $(esc(g))($(x...))\n",
    "    end\n",
    "end\n",
    "@fadd(h,p,q,1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "fe72b539",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mh\u001b[22m \u001b[0m\u001b[1mh\u001b[22m1 \u001b[0m\u001b[1mh\u001b[22melp \u001b[0m\u001b[1mh\u001b[22mton \u001b[0m\u001b[1mh\u001b[22mtol \u001b[0m\u001b[1mh\u001b[22mcat \u001b[0m\u001b[1mh\u001b[22mash \u001b[0m\u001b[1mh\u001b[22mypot \u001b[0m\u001b[1mh\u001b[22mvcat \u001b[0m\u001b[1mH\u001b[22mTML \u001b[0m\u001b[1mh\u001b[22mvncat \u001b[0m\u001b[1mh\u001b[22maskey \u001b[0m\u001b[1mh\u001b[22momedir \u001b[0m\u001b[1mh\u001b[22masfield \u001b[0m\u001b[1mh\u001b[22mardlink\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "Functions p and q added together. Created with the \\texttt{@fadd} macro!\n",
       "\n"
      ],
      "text/markdown": [
       "Functions p and q added together. Created with the `@fadd` macro!\n"
      ],
      "text/plain": [
       "  Functions p and q added together. Created with the \u001b[36m@fadd\u001b[39m macro!"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?h"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60a3a9ef",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Other Resources\n",
    "\n",
    "The [Julia Documentation](https://docs.julialang.org/en/v1/) is a great place to read about Julia features. Numerous examples are normally given along with detailed explanation.\n",
    "\n",
    "The [official Julia website](https://julialang.org/) is a great place to find [Julia tutorials](https://julialang.org/learning/), learn about the [Julia community](https://julialang.org/community/) or discover [research](https://julialang.org/research/) using Julia."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "158db323",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Questions?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4a10e5a",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Julia 1.8.1",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}