Julia_for_Pythonistas.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Julia_for_Pythonistas.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Julia",
      "language": "julia",
      "name": "julia"
    },
    "language_info": {
      "file_extension": ".jl",
      "mimetype": "application/julia",
      "name": "julia"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tQ1r1bbb0yBv"
      },
      "source": [
        "# <img src=\"https://github.com/JuliaLang/julia-logo-graphics/raw/master/images/julia-logo-color.png\" height=\"100\" /> _for Pythonistas_\n",
        "\n",
        "> TL;DR: _Julia looks and feels a lot like Python, only much faster. It's dynamic, expressive, extensible, with batteries included, in particular for Data Science_.\n",
        "\n",
        "This notebook is an **introduction to Julia for Python programmers**.\n",
        "\n",
        "It will go through the most important Python features (such as functions, basic types, list comprehensions, exceptions, generators, modules, packages, and so on) and show you how to code them in Julia."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f_1dr-2W5iSU"
      },
      "source": [
        "# Getting Started with Julia in Colab/Jupyter\n",
        "You can either run this notebook in Google Colab, or using Jupyter on your own machine."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ew60wXrZM0W"
      },
      "source": [
        "## Running on Google Colab\n",
        "1. Work on a copy of this notebook: _File_ > _Save a copy in Drive_ (you will need a Google account). Alternatively, you can download the notebook using _File_ > _Download .ipynb_, then upload it to [Colab](https://colab.research.google.com/).\n",
        "2. Execute the following cell (click on it and press Ctrl+Enter) to install Julia, IJulia (the Jupyter kernel for Julia) and other packages. You can update `JULIA_VERSION` and the other parameters, if you know what you're doing. Installation takes 2-3 minutes.\n",
        "3. Reload this page (press Ctrl+R, or ⌘+R, or the F5 key) and continue to the _Checking the Installation_ section.\n",
        "\n",
        "* _Note_: If your Colab Runtime gets reset (e.g., due to inactivity), repeat steps 2 and 3."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GIeFXS0F0zww",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c3ec755d-84ea-4d50-f6a1-36faeba72e32"
      },
      "source": [
        "%%shell\n",
        "set -e\n",
        "\n",
        "#---------------------------------------------------#\n",
        "JULIA_VERSION=\"1.6.0\" # any version ≥ 0.7.0\n",
        "JULIA_PACKAGES=\"IJulia BenchmarkTools PyCall PyPlot\"\n",
        "JULIA_PACKAGES_IF_GPU=\"CUDA\"\n",
        "JULIA_NUM_THREADS=4\n",
        "#---------------------------------------------------#\n",
        "\n",
        "if [ -n \"$COLAB_GPU\" ] && [ -z `which julia` ]; then\n",
        "  # Install Julia\n",
        "  JULIA_VER=`cut -d '.' -f -2 <<< \"$JULIA_VERSION\"`\n",
        "  echo \"Installing Julia $JULIA_VERSION on the current Colab Runtime...\"\n",
        "  BASE_URL=\"https://julialang-s3.julialang.org/bin/linux/x64\"\n",
        "  URL=\"$BASE_URL/$JULIA_VER/julia-$JULIA_VERSION-linux-x86_64.tar.gz\"\n",
        "  wget -nv $URL -O /tmp/julia.tar.gz # -nv means \"not verbose\"\n",
        "  tar -x -f /tmp/julia.tar.gz -C /usr/local --strip-components 1\n",
        "  rm /tmp/julia.tar.gz\n",
        "\n",
        "  # Install Packages\n",
        "  if [ \"$COLAB_GPU\" = \"1\" ]; then\n",
        "      JULIA_PACKAGES=\"$JULIA_PACKAGES $JULIA_PACKAGES_IF_GPU\"\n",
        "  fi\n",
        "  for PKG in `echo $JULIA_PACKAGES`; do\n",
        "    echo \"Installing Julia package $PKG...\"\n",
        "    julia -e 'using Pkg; pkg\"add '$PKG'; precompile;\"' &> /dev/null\n",
        "  done\n",
        "\n",
        "  # Install kernel and rename it to \"julia\"\n",
        "  echo \"Installing IJulia kernel...\"\n",
        "  julia -e 'using IJulia; IJulia.installkernel(\"julia\", env=Dict(\n",
        "      \"JULIA_NUM_THREADS\"=>\"'\"$JULIA_NUM_THREADS\"'\"))'\n",
        "  KERNEL_DIR=`julia -e \"using IJulia; print(IJulia.kerneldir())\"`\n",
        "  KERNEL_NAME=`ls -d \"$KERNEL_DIR\"/julia*`\n",
        "  mv -f $KERNEL_NAME \"$KERNEL_DIR\"/julia  \n",
        "\n",
        "  echo ''\n",
        "  echo \"Successfully installed `julia -v`!\"\n",
        "  echo \"Please reload this page (press Ctrl+R, ⌘+R, or the F5 key) then\"\n",
        "  echo \"jump to the 'Checking the Installation' section.\"\n",
        "fi"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Installing Julia 1.6.0 on the current Colab Runtime...\n",
            "2021-03-26 08:43:45 URL:https://storage.googleapis.com/julialang2/bin/linux/x64/1.6/julia-1.6.0-linux-x86_64.tar.gz [112838927/112838927] -> \"/tmp/julia.tar.gz\" [1]\n",
            "Installing Julia package IJulia...\n",
            "Installing Julia package BenchmarkTools...\n",
            "Installing Julia package PyCall...\n",
            "Installing Julia package PyPlot...\n",
            "Installing Julia package CUDA...\n",
            "Installing IJulia kernel...\n",
            "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mInstalling julia kernelspec in /root/.local/share/jupyter/kernels/julia-1.6\n",
            "\n",
            "Successfully installed julia version 1.6.0!\n",
            "Please reload this page (press Ctrl+R, ⌘+R, or the F5 key) then\n",
            "jump to the 'Checking the Installation' section.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              ""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ZvetMlVYKXY"
      },
      "source": [
        "## Running This Notebook Locally\n",
        "If you prefer to run this notebook on your machine instead of Google Colab:\n",
        "\n",
        "* Download this notebook (File > Download .ipynb)\n",
        "* Install [Julia](https://julialang.org/downloads/)\n",
        "* Run the following command in a terminal to install `IJulia` (the Jupyter kernel for Julia), and a few packages we will use:\n",
        "```bash\n",
        "julia -e 'using Pkg\n",
        "            pkg\"add IJulia; precompile;\"\n",
        "            pkg\"add BenchmarkTools; precompile;\"\n",
        "            pkg\"add PyCall; precompile;\"\n",
        "            pkg\"add PyPlot; precompile;\"'\n",
        "```\n",
        "\n",
        "* Next, go to the directory containing this notebook:\n",
        "\n",
        "    ```julia\n",
        "cd /path/to/notebook/directory\n",
        "```\n",
        "\n",
        "* Start Jupyter Notebook:\n",
        "\n",
        "    ```bash\n",
        "julia -e 'using IJulia; IJulia.notebook()'\n",
        "```\n",
        "\n",
        "    Or replace `notebook()` with `jupyterlab()` if you prefer JupyterLab.\n",
        "\n",
        "    If you do not already have [Jupyter](https://jupyter.org/install) installed, IJulia will propose to install it. If you agree, it will automatically install a private Miniconda (just for Julia), and install Jupyter and Python inside it.\n",
        "\n",
        "* Lastly, open this notebook and skip directly to the next section."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-OS3Ac017T1i"
      },
      "source": [
        "## Checking the Installation\n",
        "The `versioninfo()` function should print your Julia version and some other info about the system (if you ever ask for help or file an issue about Julia, you should always provide this information)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EEzvvzCl1i0F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d4cbf09f-23f4-4f0c-a6ef-29f0f3b4edd6"
      },
      "source": [
        "versioninfo()"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Julia Version 1.6.0\n",
            "Commit f9720dc2eb (2021-03-24 12:55 UTC)\n",
            "Platform Info:\n",
            "  OS: Linux (x86_64-pc-linux-gnu)\n",
            "  CPU: Intel(R) Xeon(R) CPU @ 2.20GHz\n",
            "  WORD_SIZE: 64\n",
            "  LIBM: libopenlibm\n",
            "  LLVM: libLLVM-11.0.1 (ORCJIT, broadwell)\n",
            "Environment:\n",
            "  JULIA_NUM_THREADS = 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GnSoOX6btmkh"
      },
      "source": [
        "# Getting Help\n",
        "To get help on any module, function, variable, or just about anything else, just type `?` followed by what you're interested in. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-4FMkizktjB5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 120
        },
        "outputId": "457aeba0-4999-4d40-a147-3a2fda431d12"
      },
      "source": [
        "?versioninfo"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "search: \u001b[0m\u001b[1mv\u001b[22m\u001b[0m\u001b[1me\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/latex": "\\begin{verbatim}\nversioninfo(io::IO=stdout; verbose::Bool=false)\n\\end{verbatim}\nPrint information about the version of Julia in use. The output is controlled with boolean keyword arguments:\n\n\\begin{itemize}\n\\item \\texttt{verbose}: print all additional information\n\n\\end{itemize}\n",
            "text/markdown": "```\nversioninfo(io::IO=stdout; verbose::Bool=false)\n```\n\nPrint information about the version of Julia in use. The output is controlled with boolean keyword arguments:\n\n  * `verbose`: print all additional information\n",
            "text/plain": [
              "\u001b[36m  versioninfo(io::IO=stdout; verbose::Bool=false)\u001b[39m\n",
              "\n",
              "  Print information about the version of Julia in use. The output is\n",
              "  controlled with boolean keyword arguments:\n",
              "\n",
              "    •  \u001b[36mverbose\u001b[39m: print all additional information"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iAZabyzVEKlX"
      },
      "source": [
        "This works in interactive mode only: in Jupyter, Colab and in the Julia shell (called the REPL)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QvXUXo-XUt3h"
      },
      "source": [
        "Here are a few more ways to get help and inspect objects in interactive mode:\n",
        "\n",
        "|Julia|Python\n",
        "|-----|------\n",
        "|`?obj` | `help(obj)`\n",
        "|`dump(obj)` | `print(repr(obj))`\n",
        "|`names(FooModule)` | `dir(foo_module)`\n",
        "|`methodswith(SomeType)` | `dir(SomeType)`\n",
        "|`@which func` | `func.__module__`\n",
        "|`apropos(\"bar\")` | Search for `\"bar\"` in docstrings of all installed packages\n",
        "|`typeof(obj)` | `type(obj)`\n",
        "|`obj isa SomeType`<br />or<br />`isa(obj, SomeType)` | `isinstance(obj, SomeType)`\n",
        "\n",
        "If you ever ask for help or file an issue about Julia, you should generally provide the output of `versioninfo()`.\n",
        "\n",
        "And of course, you can also learn and get help here:\n",
        "\n",
        "* Learning: https://julialang.org/learning/\n",
        "* Documentation: https://docs.julialang.org/\n",
        "* Questions & Discussions:\n",
        "  * https://discourse.julialang.org/\n",
        "  * http://julialang.slack.com/\n",
        "  * https://stackoverflow.com/questions/tagged/julia"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TB3UQ7RQZZtP"
      },
      "source": [
        "# A First Look at Julia\n",
        "This section will give you an idea of what Julia looks like and what some of its major qualities are: it's expressive, dynamic, flexible, and most of all, super fast."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tBKp4lciICdi"
      },
      "source": [
        "## Estimating π\n",
        "Let's write our first function. It will estimate π using the equation:\n",
        "$π = 4 \\times \\left(1 - \\dfrac{1}{3} + \\dfrac{1}{5} - \\dfrac{1}{7} + \\dfrac{1}{9}-\\dfrac{1}{11}+\\dots\\right)$\n",
        "\n",
        "There are much better ways to estimate π, but this one is easy to implement."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EPRfV4_XI2Rk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9d015157-5731-4b65-a201-cf443609a941"
      },
      "source": [
        "function estimate_pi(n)\n",
        "    s = 1.0\n",
        "    for i in 1:n\n",
        "        s += (isodd(i) ? -1 : 1) / (2i + 1)\n",
        "    end\n",
        "    4s\n",
        "end\n",
        "\n",
        "p = estimate_pi(100_000_000)\n",
        "println(\"π ≈ $p\")\n",
        "println(\"Error is $(p - π)\")"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "π ≈ 3.141592663589326\n",
            "Error is 9.999532757376528e-9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5SGZnQB3cug3"
      },
      "source": [
        "**Note**: syntax highlighting for Julia does not work (yet?) on Colab, but it does in Jupyter."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iYJZNTLCLdU3"
      },
      "source": [
        "Compare this with the equivalent Python 3 code:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F98h-og4KHHn"
      },
      "source": [
        "```python\n",
        "# PYTHON\n",
        "import math\n",
        "\n",
        "def estimate_pi(n):\n",
        "    s = 1.0\n",
        "    for i in range(1, n + 1):\n",
        "        s += (-1 if i % 2 else 1) / (2 * i + 1)\n",
        "    return 4 * s\n",
        "\n",
        "p = estimate_pi(100_000_000)\n",
        "print(f\"π ≈ {p}\") # f-strings are available in Python 3.6+\n",
        "print(f\"Error is {p - math.pi}\")\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zZl4GRE0LuEc"
      },
      "source": [
        "Pretty similar, right? But notice the small differences:\n",
        "\n",
        "|Julia|Python\n",
        "|-----|------\n",
        "|`function` | `def`\n",
        "|`for i in X`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end` | `for i in X:`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`\n",
        "|`1:n` | `range(1, n+1)`\n",
        "|`cond ? a : b` | `a if cond else b`\n",
        "|`2i + 1` | `2 * i + 1`\n",
        "|`4s` | `return 4 * s`\n",
        "|`println(a, b)` | `print(a, b, sep=\"\")`\n",
        "|`print(a, b)` | `print(a, b, sep=\"\", end=\"\")`\n",
        "|`\"$p\"` | `f\"{p}\"`\n",
        "|`\"$(p - π)\"` | `f\"{p - math.pi}\"`\n",
        "\n",
        "This example shows that:\n",
        "* Julia can be just as concise and readable as Python.\n",
        "* Indentation in Julia is _not_ meaningful like it is in Python. Instead, blocks end with `end`.\n",
        "* Many math features are built in Julia and need no imports.\n",
        "* There's some mathy syntactic sugar, such as `2i` (but you can write `2 * i` if you prefer).\n",
        "* In Julia, the `return` keyword is optional at the end of a function. The result of the last expression is returned (`4s` in this example).\n",
        "* Julia loves Unicode and does not hesitate to use Unicode characters like `π`. However, there are generally plain-ASCII equivalents (e.g., `π == pi`)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C81648ZjKljL"
      },
      "source": [
        "## Typing Unicode Characters"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ceBdy_lFKoFz"
      },
      "source": [
        "Typing Unicode characters is easy: for latex symbols like π, just type `\\pi<tab>`. For emojis like 😃, type `\\:smiley:<tab>`.\n",
        "\n",
        "This works in the REPL, in Jupyter, but unfortunately not in Colab (yet?). As a workaround, you can run the following code to print the character you want, then copy/paste it:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6nvl3qveKHld",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17dfeb80-a7f2-4d4d-e4f1-9239514f37e4"
      },
      "source": [
        "using REPL.REPLCompletions: latex_symbols, emoji_symbols\n",
        "\n",
        "latex_symbols[\"\\\\pi\"]"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"π\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RUHi_sDKLGL5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f2ea85db-ef0e-415b-8d51-1159709f779f"
      },
      "source": [
        "emoji_symbols[\"\\\\:smiley:\"]"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"😃\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9at61Y3LLJWX"
      },
      "source": [
        "In Julia, `using Foo.Bar: a, b` corresponds to running `from foo.bar import a, b` in Python.\n",
        "\n",
        "|Julia|Python\n",
        "|-----|------\n",
        "|`using Foo` | `from foo import *; import foo`\n",
        "|`using Foo.Bar` | `from foo.bar import *; from foo import bar`\n",
        "|`using Foo.Bar: a, b` | `from foo.bar import a, b`\n",
        "|`using Foo: Bar` | `from foo import bar`\n",
        "\n",
        "More on this later."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0CnQq32IaDGD"
      },
      "source": [
        "## Running Python code in Julia\n",
        "Julia lets you easily run Python code using the `PyCall` module. We installed it earlier, so we just need to import it:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SHCsfibyaBRk"
      },
      "source": [
        "using PyCall"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x7Qk9ht-d8Vo"
      },
      "source": [
        "Now that we have imported `PyCall`, we can use the `pyimport()` function to import a Python module directly in Julia! For example, let's check which Python version we are using:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LlB4nMZVeZmY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09f90cc6-6bfd-44a2-cf9a-4542b19e5e0a"
      },
      "source": [
        "sys = pyimport(\"sys\")\n",
        "sys.version"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"3.7.10 (default, Feb 20 2021, 21:17:23) \\n[GCC 7.5.0]\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YwM2lGhmjIAA"
      },
      "source": [
        "In fact, let's run the Python code we discussed earlier (this will take about 15 seconds to run, because Python is so slow...):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MrhaObEaJ_sB"
      },
      "source": [
        "py\"\"\"\n",
        "import math\n",
        " \n",
        "def estimate_pi(n):\n",
        "    s = 1.0\n",
        "    for i in range(1, n + 1):\n",
        "        s += (-1 if i % 2 else 1) / (2 * i + 1)\n",
        "    return 4 * s\n",
        " \n",
        "p = estimate_pi(100_000_000)\n",
        "print(f\"π ≈ {p}\") # f-strings are available in Python 3.6+\n",
        "print(f\"Error is {p - math.pi}\")\n",
        "\"\"\"\n"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PHemaGjSja7O"
      },
      "source": [
        "As you can see, running arbitrary Python code is as simple as using py-strings (`py\"...\"`). Note that py-strings are not part of the Julia language itself: they are defined by the `PyCall` module (we will see how this works later).\n",
        "\n",
        "Unfortunately, Python's `print()` function writes to the standard output, which is not captured by Colab, so we can't see the output of this code. That's okay, we can look at the value of `p`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5z_QlxhJLRJ5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1bfde083-22a6-4bc8-92ee-86d6fb02aec1"
      },
      "source": [
        "py\"p\""
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.141592663589326"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jBx7UcHtkMa-"
      },
      "source": [
        "Let's compare this to the value we calculated above using Julia:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sKNlJjjSkIo0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "93128e3c-4684-4cfb-f39f-940e0dd332cc"
      },
      "source": [
        "py\"p\" - p"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AOzbgPMMksUb"
      },
      "source": [
        "Perfect, they are exactly equal!\n",
        "\n",
        "As you can see, it's very easy to mix Julia and Python code. So if there's a module you really love in Python, you can keep using it as long as you want! For example, let's use NumPy:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uXSDig4XrKyS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6f992155-e682-4ebd-8f88-30fba38af720"
      },
      "source": [
        "np = pyimport(\"numpy\")\n",
        "a = np.random.rand(2, 3)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2×3 Matrix{Float64}:\n",
              " 0.238144  0.0863742  0.399377\n",
              " 0.819097  0.283829   0.726097"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zPMwgIaeyRBh"
      },
      "source": [
        "Notice that `PyCall` automatically converts some Python types to Julia types, including NumPy arrays. That's really quite convenient! Note that Julia supports multi-dimensional arrays (analog to NumPy arrays) out of the box. `Array{Float64, 2}` means that it's a 2-dimensional array of 64-bit floats.\n",
        "\n",
        "`PyCall` also converts Julia arrays to NumPy arrays when needed:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aWAC4wxqrxCb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cd1b5248-ca8f-48f4-9565-72c4b7298e40"
      },
      "source": [
        "exp_a = np.exp(a)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2×3 Matrix{Float64}:\n",
              " 1.26889  1.09021  1.4909\n",
              " 2.26845  1.32821  2.067"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gy8gZ8pp3Z0n"
      },
      "source": [
        "If you want to use some Julia variable in a py-string, for example `exp_a`, you can do so by writing `$exp_a` like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dxQ25HpJ3oPA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b98b920d-e1a0-4af8-cbe9-a33c67a98f20"
      },
      "source": [
        "py\"\"\"\n",
        "import numpy as np\n",
        "\n",
        "result = np.log($exp_a)\n",
        "\"\"\"\n",
        "\n",
        "py\"result\""
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2×3 Matrix{Float64}:\n",
              " 0.238144  0.0863742  0.399377\n",
              " 0.819097  0.283829   0.726097"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jtxk8kebxFdM"
      },
      "source": [
        "If you want to keep using Matplotlib, it's best to use the `PyPlot` module (which we installed earlier), rather than trying to use `pyimport(\"matplotlib\")`, as `PyPlot` provides a more straightforward interface with Julia, and it plays nicely with Jupyter and Colab:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gyHkEL7ExPg2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "outputId": "8ddd3d91-c679-4a0d-debf-4ce57a2e7d2a"
      },
      "source": [
        "using PyPlot\n",
        "\n",
        "x = range(-5π, 5π, length=100)\n",
        "plt.plot(x, sin.(x) ./ x) # we'll discuss this syntax in the next section\n",
        "plt.title(\"sin(x) / x\")\n",
        "plt.grid(\"True\")\n",
        "plt.show()"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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",
            "text/plain": [
              "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b42BIiqN6JM_"
      },
      "source": [
        "That said, Julia has its own plotting libraries, such as the `Plots` library, which you may want to check out."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FGStdgNK9IG1"
      },
      "source": [
        "As you can see, Julia's `range()` function acts much like NumPy's `linspace()` function, when you use the `length` argument. However, it acts like Python's `range()` function when you use the `step` argument instead (except the upper bound is inclusive). Julia's `range()` function returns an object which behaves just like an array, except it doesn't actually use any RAM for its elements, it just stores the range parameters. If you want to collect all of the elements into an array, use the `collect()` function (similar to Python's `list()` function):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h728H-f9-rC_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c7e2a11-fff6-4362-bb62-5f9e9743752f"
      },
      "source": [
        "println(collect(range(10, 80, step=20)))\n",
        "println(collect(10:20:80)) # 10:20:80 is equivalent to the previous range\n",
        "println(collect(range(10, 80, length=5))) # similar to NumPy's linspace()\n",
        "step = (80-10)/(5-1) # 17.5\n",
        "println(collect(10:step:80)) # equivalent to the previous range"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10, 30, 50, 70]\n",
            "[10, 30, 50, 70]\n",
            "[10.0, 27.5, 45.0, 62.5, 80.0]\n",
            "[10.0, 27.5, 45.0, 62.5, 80.0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gAU4t9zl72PW"
      },
      "source": [
        "The equivalent Python code is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "print(list(range(10, 80+1, 20)))\n",
        "# there's no short-hand for range() in Python\n",
        "print(np.linspace(10, 80, 5))\n",
        "step = (80-10)/(5-1) # 17.5\n",
        "print([i*step + 10 for i in range(5)])\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ucA1zMkw-n_U"
      },
      "source": [
        "|Julia|Python\n",
        "|-----|------\n",
        "|`np = pyimport(\"numpy\")` | `import numpy as np`\n",
        "|`using PyPlot` | `from pylab import *`\n",
        "|`1:10` | `range(1, 11)`\n",
        "|`1:2:10`<br />or<br />`range(1, 11, 2)` | `range(1, 11, 2)`\n",
        "|`1.2:0.5:10.3`<br />or<br />`range(1.2, 10.3, step=0.5)` | `np.arange(1.2, 10.3, 0.5)`\n",
        "|`range(1, 10, length=3)` | `np.linspace(1, 10, 3)`\n",
        "|`collect(1:5)`<br />or<br />`[i for i in 1:5]` | `list(range(1, 6))`<br />or<br />`[i for i in range(1, 6)]`\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1iiE76xA8pwr"
      },
      "source": [
        "## Loop Fusion\n",
        "Did you notice that we wrote `sin.(x) ./ x` (not `sin(x) / x`)? This is equivalent to `[sin(i) / i for i in x]`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kjXg63Hmd2ux"
      },
      "source": [
        "a = sin.(x) ./ x\n",
        "b = [sin(i) / i for i in x]\n",
        "@assert a == b"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wX26wG02d1KI"
      },
      "source": [
        " This is not just syntactic sugar: it's actually a very powerful Julia feature. Indeed, notice that the array only gets traversed once. Even if we chained more than two dotted operations, the array would still only get traversed once. This is called _loop fusion_.\n",
        "\n",
        "In contrast, when using NumPy arrays, `sin(x) / x` first computes a temporary array containing `sin(x)` and then it computes the final array. Two loops and two arrays instead of one. NumPy is implemented in C, and has been heavily optimized, but if you chain many operations, it still ends up being slower and using more RAM than Julia.\n",
        "\n",
        "However, all the extra dots can sometimes make the code a bit harder to read. To avoid that, you can write `@.` before an expression: every operation will be \"dotted\" automatically, like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "raOw65bd-Qeg"
      },
      "source": [
        "a = @. sin(x) / x\n",
        "b = sin.(x) ./ x\n",
        "@assert a == b"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ys5cFYaogb2"
      },
      "source": [
        "**Note**: Julia's `@assert` statement starts with an `@` sign, just like `@.`, which means that they are macros. In Julia, macros are very powerful metaprogramming tools: a macro is evaluated at parse time, and it can inspect the expression that follows it and then transform it, or even replace it. In practice, you will often _use_ macros, but you will rarely _define_ your own. I'll come back to macros later."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MQ1U3aAwk5iD"
      },
      "source": [
        "## Julia is fast!\n",
        "Let's compare the Julia and Python implementations of the `estimate_pi()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pXQbFKYgk9gG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "40986449-f922-438d-b692-b83be3a7ed36"
      },
      "source": [
        "@time estimate_pi(100_000_000);"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  0.136262 seconds\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2B7Vu5lepqOW"
      },
      "source": [
        "To get a more precise benchmark, it's preferable to use the `BenchmarkTools` module. Just like Python's `timeit` module, it provides tools to benchmark code by running it multiple times. This provides a better estimate of how long each call takes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xK4b8X_cppNQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "795e3b0f-a1b7-4eb9-f62a-a64ef5b02222"
      },
      "source": [
        "using BenchmarkTools\n",
        "\n",
        "@benchmark estimate_pi(100_000_000)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "BenchmarkTools.Trial: \n",
              "  memory estimate:  0 bytes\n",
              "  allocs estimate:  0\n",
              "  --------------\n",
              "  minimum time:     133.983 ms (0.00% GC)\n",
              "  median time:      137.002 ms (0.00% GC)\n",
              "  mean time:        137.845 ms (0.00% GC)\n",
              "  maximum time:     151.005 ms (0.00% GC)\n",
              "  --------------\n",
              "  samples:          37\n",
              "  evals/sample:     1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xHsab0EkqObG"
      },
      "source": [
        "If this output is too verbose for you, simply use `@btime` instead:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FqbViO67qN6E",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "83bab414-e2ba-4ac5-e542-55e56c1019bd"
      },
      "source": [
        "@btime estimate_pi(100_000_000)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  132.447 ms (0 allocations: 0 bytes)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.141592663589326"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JOEUCAn6qghC"
      },
      "source": [
        "Now let's time the Python version. Since the call is so slow, we just run it once (it will take about 15 seconds):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6dk8QgRL0mzd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b5fa2b24-799d-4507-eb26-3384e7e83eef"
      },
      "source": [
        "py\"\"\"\n",
        "from timeit import timeit\n",
        "\n",
        "duration = timeit(\"estimate_pi(100_000_000)\", number=1, globals=globals())\n",
        "\"\"\"\n",
        "\n",
        "py\"duration\""
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "13.743782259"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jqtx4_erlxky"
      },
      "source": [
        "It looks like Julia is close to 100 times faster than Python in this case! To be fair, `PyCall` does add some overhead, but even if you run this code in a separate Python shell, you will see that Julia crushes (pure) Python when it comes to speed."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hiVDodlPmzoP"
      },
      "source": [
        "So why is Julia so much faster than Python? Well, **Julia compiles the code on the fly as it runs it**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w-HSoqJ8ts7P"
      },
      "source": [
        "Okay, let's summarize what we learned so far: Julia is a dynamic language that looks and feels a lot like Python, you can even execute Python code super easily, and pure Julia code runs much faster than pure Python code, because it is compiled on the fly. I hope this convinces you to read on!\n",
        "\n",
        "Next, let's continue to see how Python's main constructs can be implemented in Julia."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n1exnPNvtsvh"
      },
      "source": [
        "# Numbers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NKscy9dmtsk8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "98f5eb08-5b73-4082-bf38-54386a8e710a"
      },
      "source": [
        "i = 42 # 64-bit integer\n",
        "f = 3.14 # 64-bit float\n",
        "c = 3.4 + 4.5im # 128-bit complex number\n",
        "\n",
        "bi = BigInt(2)^1000 # arbitrarily long integer\n",
        "bf = BigFloat(1) / 7 # arbitrary precision\n",
        "\n",
        "r = 15//6 * 9//20 # rational number"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9//8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PzLbmPApyPLc"
      },
      "source": [
        "And the equivalent Python code:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "i = 42\n",
        "f = 3.14\n",
        "c = 3.4 + 4.5j\n",
        "\n",
        "bi = 2**1000 # integers are seemlessly promoted to long integers\n",
        "from decimal import Decimal\n",
        "bf = Decimal(1) / 7\n",
        "\n",
        "from fractions import Fraction\n",
        "r = Fraction(15, 6) * Fraction(9, 20)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "obkfXw_LAZ2B"
      },
      "source": [
        "Dividing integers gives floats, like in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MQ_YTxNgAiLA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "979c9db3-c8c3-42e2-a70e-48e207a36bec"
      },
      "source": [
        "5 / 2"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lqAUqZqNAkhb"
      },
      "source": [
        "For integer division, use `÷` or `div()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xPkuXvQHArxo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d72c5811-fddf-47b7-924c-ae3773e5288a"
      },
      "source": [
        "5 ÷ 2"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bg26ib-cAtoF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "134bfada-746d-42b9-cd58-ece7cf77e667"
      },
      "source": [
        "div(5, 2)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GwsmLJ4kAvLQ"
      },
      "source": [
        "The `%` operator is the remainder, not the modulo like in Python. These differ only for negative numbers:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BqYAfPWBA5UZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff8d705f-ce3d-45df-d733-83fd90042fb3"
      },
      "source": [
        "57 % 10"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i_0nKGW0A8TZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f54fc0ad-9550-4aa1-ca91-0032ab42b079"
      },
      "source": [
        "(-57) % 10"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5euGtSBl95e_"
      },
      "source": [
        "|Julia|Python\n",
        "|-----|------\n",
        "|`3.4 + 4.5im` | `3.4 + 4.5j`\n",
        "|`BigInt(2)^1000` | `2**1000`\n",
        "|`BigFloat(3.14)` | `from decimal import Decimal`<br />`Decimal(3.14)`\n",
        "|`9//8` | `from fractions import Fraction`<br />`Fraction(9, 8)`\n",
        "|`5/2 == 2.5` | `5/2 == 2.5`\n",
        "|`5÷2 == 2`<br />or<br />`div(5, 2)` | `5//2 == 2`\n",
        "|`57%10 == 7` | `57%10 == 7`\n",
        "|`(-57)%10 == -7` | `(-57)%10 == 3`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "koGxWy1D1nd2"
      },
      "source": [
        "# Strings\n",
        "Julia strings use double quotes `\"` or triple quotes `\"\"\"`, but not single quotes `'`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cAJ5W9PstsbQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "14ef2148-78aa-4058-a527-17aff5203454"
      },
      "source": [
        "s = \"ångström\" # Julia strings are UTF-8 encoded by default\n",
        "println(s)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ångström\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_7bPa-W7c3dZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eae1bab1-b9c2-43e3-fcee-fc12d1d632f8"
      },
      "source": [
        "s = \"Julia strings\n",
        "     can span\n",
        "     several lines\\n\\n\n",
        "     and they support the \\\"usual\\\" escapes like\n",
        "     \\x41, \\u5bb6, and \\U0001f60a!\"\n",
        "println(s)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Julia strings\n",
            "     can span\n",
            "     several lines\n",
            "\n",
            "\n",
            "     and they support the \"usual\" escapes like\n",
            "     A, 家, and 😊!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sr6f6JBzfsc_"
      },
      "source": [
        "Use `repeat()` instead of `*` to repeat a string, and use `*` instead of `+` for concatenation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R52WXKlMc5h9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c68ef48-87e5-41cb-9567-b41b06382643"
      },
      "source": [
        "s = repeat(\"tick, \", 10) * \"BOOM!\"\n",
        "println(s)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tick, tick, tick, tick, tick, tick, tick, tick, tick, tick, BOOM!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1QvDoWolgC1v"
      },
      "source": [
        "The equivalent Python code is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "s = \"tick, \" * 10 + \"BOOM!\"\n",
        "print(s)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UULsUFcTgPXN"
      },
      "source": [
        "Use `join(a, s)` instead of `s.join(a)`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pMZNYWTxd3N2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab3aca69-5c0a-4cec-a5aa-edd848744ef8"
      },
      "source": [
        "s = join([i for i in 1:4], \", \")\n",
        "println(s)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1, 2, 3, 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ejbvMUySgaTn"
      },
      "source": [
        "You can also specify a string for the last join:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wRx3SN5fdWFf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bfe57909-8491-48b5-bc38-8c9e8e4782ee"
      },
      "source": [
        "s = join([i for i in 1:4], \", \", \" and \")"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"1, 2, 3 and 4\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GJAbtqLg6T5s"
      },
      "source": [
        "`split()` works as you might expect:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kqkgq7IA6FWl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de41d6a1-b478-4246-82bb-1505d82f0806"
      },
      "source": [
        "split(\"   one    three     four   \")"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3-element Vector{SubString{String}}:\n",
              " \"one\"\n",
              " \"three\"\n",
              " \"four\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3cy_kYpZ6A7U",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4dd244bd-9f20-46da-ccd0-ab0df569e8cb"
      },
      "source": [
        "split(\"one,,three,four!\", \",\")"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{SubString{String}}:\n",
              " \"one\"\n",
              " \"\"\n",
              " \"three\"\n",
              " \"four!\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gdI7lnQ6n7RD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "740dd673-2328-4b57-aa35-4758278370a1"
      },
      "source": [
        "occursin(\"sip\", \"Mississippi\")"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gnLjg6UpvKrL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f3f9d4cf-ac98-4524-ec11-1cf366b070f2"
      },
      "source": [
        "replace(\"I like coffee\", \"coffee\" => \"tea\")"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"I like tea\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_dMkcaL4gm_n"
      },
      "source": [
        "Triple quotes work a bit like in Python, but they also remove indentation and ignore the first line feed:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7Qc3Nn81ed3j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ca008b47-6d97-4c64-a842-0dc9003e9e0c"
      },
      "source": [
        "s = \"\"\"\n",
        "       1. the first line feed is ignored if it immediately follows \\\"\"\"\n",
        "       2. triple quotes let you use \"quotes\" easily\n",
        "       3. indentation is ignored\n",
        "           - up to left-most character\n",
        "           - ignoring the first line (the one with \\\"\"\")\n",
        "       4. the final line feed it n̲o̲t̲ ignored\n",
        "       \"\"\"\n",
        "println(\"<start>\")\n",
        "println(s)\n",
        "println(\"<end>\")"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<start>\n",
            "1. the first line feed is ignored if it immediately follows \"\"\"\n",
            "2. triple quotes let you use \"quotes\" easily\n",
            "3. indentation is ignored\n",
            "    - up to left-most character\n",
            "    - ignoring the first line (the one with \"\"\")\n",
            "4. the final line feed it n̲o̲t̲ ignored\n",
            "\n",
            "<end>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T0cx6rWpjIzc"
      },
      "source": [
        "## String Interpolation\n",
        "String interpolation uses `$variable` and `$(expression)`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Nl2AlRvg2c_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "080514d3-4c74-4409-b555-f2c10830b34c"
      },
      "source": [
        "total = 1 + 2 + 3\n",
        "s = \"1 + 2 + 3 = $total = $(1 + 2 + 3)\"\n",
        "println(s)"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 + 2 + 3 = 6 = 6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NToitF2YjRP1"
      },
      "source": [
        "This means you must escape the `$` sign:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AUeXBJIdjUmB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab87c4f1-f4e6-4891-c48b-46ea98528b07"
      },
      "source": [
        "s = \"The car costs \\$10,000\"\n",
        "println(s)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The car costs $10,000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fk8BuKKtjhmo"
      },
      "source": [
        "## Raw Strings\n",
        "Raw strings use `raw\"...\"` instead of `r\"...\"`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KQ9U5Ivai86F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2cecb666-5ab4-4267-c3ee-a0d55ad4c611"
      },
      "source": [
        "s = raw\"In a raw string, you only need to escape quotes \\\", but not\n",
        "        $ or \\. There is one exception, however: the backslash \\\n",
        "        must be escaped if it's just before quotes like \\\\\\\".\"\n",
        "println(s)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "In a raw string, you only need to escape quotes \", but not\n",
            "        $ or \\. There is one exception, however: the backslash \\\n",
            "        must be escaped if it's just before quotes like \\\".\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0cqdV9lJkclw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6d098975-a12f-4af3-942c-12da8156b9ea"
      },
      "source": [
        "s = raw\"\"\"\n",
        "   Triple quoted raw strings are possible too: $, \\, \\t, \"\n",
        "     - They handle indentation and the first line feed like regular\n",
        "       triple quoted strings.\n",
        "     - You only need to escape triple quotes like \\\"\"\", and the\n",
        "       backslash before quotes like \\\\\".\n",
        "   \"\"\"\n",
        "println(s)"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Triple quoted raw strings are possible too: $, \\, \\t, \"\n",
            "  - They handle indentation and the first line feed like regular\n",
            "    triple quoted strings.\n",
            "  - You only need to escape triple quotes like \"\"\", and the\n",
            "    backslash before quotes like \\\".\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U5eOtwDalgw-"
      },
      "source": [
        "## Characters\n",
        "Single quotes are used for individual Unicode characters:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PnNfVRZx2CsU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5df8f7f4-93df-4a5b-c719-f484dead4187"
      },
      "source": [
        "a = 'å' # Unicode code point (single quotes)"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'å': Unicode U+00E5 (category Ll: Letter, lowercase)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WA5RXfz4mBcE"
      },
      "source": [
        "To be more precise:\n",
        "* A Julia \"character\" represents a single Unicode code point (sometimes called a Unicode scalar).\n",
        "* Multiple code points may be required to produce a single _grapheme_, i.e., something that readers would recognize as a single character. Such a sequence of code points is called a \"Grapheme cluster\".\n",
        "\n",
        "For example, the character `é` can be represented either using the single code point `\\u00E9`, or the grapheme cluster `e` + `\\u0301`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "liN9OQVClokc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "64bb15a9-cdac-4b43-fce6-1edb38fa325d"
      },
      "source": [
        "s = \"café\"\n",
        "println(s, \" has \", length(s), \" code points\")"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "café has 4 code points\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CTtCiqN1oCJa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5b99d462-4999-468d-910d-44e4e0bef0bc"
      },
      "source": [
        "s = \"cafe\\u0301\"\n",
        "println(s, \" has \", length(s), \" code points\")"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "café has 5 code points\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MIBI7ULN2CYI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "2fd2d71b-c256-4d79-8304-5c03d982f2a9"
      },
      "source": [
        "for c in \"cafe\\u0301\"\n",
        "    display(c)\n",
        "end"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "'f': ASCII/Unicode U+0066 (category Ll: Letter, lowercase)"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "'́': Unicode U+0301 (category Mn: Mark, nonspacing)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oz-6luAbobDe"
      },
      "source": [
        "Julia represents any individual character like `'é'` using 32-bits (4 bytes):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Iu1otE7omZIy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9329a13c-dc88-4ea2-9535-2521c0717f2f"
      },
      "source": [
        "sizeof('é')"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "81XkzaaNmW_4"
      },
      "source": [
        "But strings are represented using the UTF-8 encoding. In this encoding, code points 0 to 127 are represented using one byte, but any code point above 127 is represented using 2 to 6 bytes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZgLS0PdImraY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "916c9998-2e32-4f6b-c48b-3136fedbd485"
      },
      "source": [
        "sizeof(\"a\")"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PSOu8j--mmzO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9b33e2d4-b06c-4387-d52a-055d3b6b20eb"
      },
      "source": [
        "sizeof(\"é\")"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5UVyrhoKmw1j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "932929ab-d617-4742-e564-1d1d45ef6b45"
      },
      "source": [
        "sizeof(\"家\")"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0HUpcANGnJYA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b38631bc-9fd3-4290-b131-dad698cef08e"
      },
      "source": [
        "sizeof(\"🏳️‍🌈\") # this is a grapheme with 4 code points of 4 + 3 + 3 + 4 bytes"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EfBbY0vHpNkG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bfd8bdba-8df7-4f92-95f7-8250878656ec"
      },
      "source": [
        "[sizeof(string(c)) for c in \"🏳️‍🌈\"]"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              " 4\n",
              " 3\n",
              " 3\n",
              " 4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "71mBRSnKo_gU"
      },
      "source": [
        "You can iterate through graphemes instead of code points:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hvHwnu4dnYNx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5cdfae1e-ca52-4b49-cb76-b269c17c82d4"
      },
      "source": [
        "using Unicode\n",
        "\n",
        "for g in graphemes(\"e\\u0301🏳️‍🌈\")\n",
        "  println(g)\n",
        "end"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "é\n",
            "🏳️‍🌈\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D52gwsw7mkls"
      },
      "source": [
        "## String Indexing\n",
        "Characters in a string are indexed based on the position of their starting byte in the UTF-8 representation. For example, the character `ê` in the string `\"être\"` is located at index 1, but the character `'t'` is located at index 3, since the UTF-8 encoding of `ê` is 2 bytes long:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wF-sqnBhobOr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f7738c3-dc1c-4aae-a632-4a6a21408b79"
      },
      "source": [
        "s = \"être\"\n",
        "println(s[1])\n",
        "println(s[3])\n",
        "println(s[4])\n",
        "println(s[5])"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ê\n",
            "t\n",
            "r\n",
            "e\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PTwNWMfywghC"
      },
      "source": [
        "If you try to get the character at index 2, you get an exception:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nVTYypUmobae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cf348f7f-2664-4435-81ac-f3ce921062a5"
      },
      "source": [
        "try\n",
        "    s[2]\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "StringIndexError(\"être\", 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h27VGo9oB2HD"
      },
      "source": [
        "By the way, notice the exception-handling syntax (we'll discuss exceptions later):\n",
        "\n",
        "|Julia|Python\n",
        "|-----|------\n",
        "|`try`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`catch ex`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end`|`try`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`except Exception as ex`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end`\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v519pXuAxhnO"
      },
      "source": [
        "You can get a substring easily, using valid character indices:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fSYrcLRPxdBv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "966eab07-9f1f-4861-fddb-79638a6a8c66"
      },
      "source": [
        "s[1:3]"
      ],
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"êt\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1aSg-yZExJaj"
      },
      "source": [
        "You can iterate through a string, and it will return all the code points:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nWzSSfi3obnG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bae12a5d-4b31-4d1b-d4fa-f0bc17b22ae0"
      },
      "source": [
        "for c in s\n",
        "    println(c)\n",
        "end"
      ],
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ê\n",
            "t\n",
            "r\n",
            "e\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4y_oW-tx1FM"
      },
      "source": [
        "Or you can iterate through the valid character indices:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Stdn7xZRx5HP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1130f48d-bb1d-4b02-eb0d-f88aeba16614"
      },
      "source": [
        "for i in eachindex(s)\n",
        "    println(i, \": \", s[i])\n",
        "end"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1: ê\n",
            "3: t\n",
            "4: r\n",
            "5: e\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6vAcDvvgyI2O"
      },
      "source": [
        "Benefits of representing strings as UTF-8:\n",
        "* All Unicode characters are supported.\n",
        "* UTF-8 is fairly compact (at least for Latin scripts).\n",
        "* It plays nicely with C libraries which expect ASCII characters only, since ASCII characters correspond to the Unicode code points 0 to 127, which UTF-8 encodes exactly like ASCII.\n",
        "\n",
        "Drawbacks:\n",
        "* UTF-8 uses a variable number of bytes per character, which makes indexing harder.\n",
        "  * However, If the language tried to hide this by making `s[5]` search for the 5th character from the start of the string, then code like `for i in 1:length(s); s[i]; end` would be unexpectedly inefficient, since at each iteration there would be a search from the beginning of the string, leading to O(_n_<sup>2</sup>) performance instead of O(_n_)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JhOHqjktdrBV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "be6ee34b-2c52-48f2-b812-00dca59898f9"
      },
      "source": [
        "findfirst(isequal('t'), \"être\")"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PUyEI4dHm-nl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19f62fb1-053e-433c-ad24-4638a0216e57"
      },
      "source": [
        "findlast(isequal('p'), \"Mississippi\")"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VA-KDam0nT9z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e5dc5560-2802-4474-a016-6063168df090"
      },
      "source": [
        "findnext(isequal('i'), \"Mississippi\", 2)"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V-18_V29ny--",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2a4a0ff5-9574-4128-e7b9-65c2864124a3"
      },
      "source": [
        "findnext(isequal('i'), \"Mississippi\", 2 + 1)"
      ],
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rF-0AVyCnoRa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "afee774d-8c61-4dbb-d941-f316ae2183b6"
      },
      "source": [
        "findprev(isequal('i'), \"Mississippi\", 5 - 1)"
      ],
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "29n4QUfloQXQ"
      },
      "source": [
        "Other useful string functions: `ncodeunits(str)`, `codeunit(str, i)`, `thisind(str, i)`, `nextind(str, i, n=1)`, `prevind(str, i, n=1)`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v93Xg1E5omZB"
      },
      "source": [
        "## Regular Expressions\n",
        "To create a regular expression in Julia, use the `r\"...\"` syntax:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LDgR-AwboyDw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3b3e48cf-853e-4446-f636-a010104aa49a"
      },
      "source": [
        "regex = r\"c[ao]ff?(?:é|ee)\""
      ],
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "r\"c[ao]ff?(?:é|ee)\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bKT4fMKMiKWo"
      },
      "source": [
        "The expression `r\"...\"` is equivalent to `Regex(\"...\")` except the former is evaluated at parse time, while the latter is evaluated at runtime, so unless you need to construct a Regex dynamically, you should prefer `r\"...\"`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "222akOU9ox3m",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7746411e-4cb7-449c-f748-c46bf6cabcbe"
      },
      "source": [
        "occursin(regex, \"A bit more coffee?\")"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QCXRSdFuoxqd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "68c3c57a-9ddd-4846-94ab-948993b69232"
      },
      "source": [
        "m = match(regex, \"A bit more coffee?\")\n",
        "m.match"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"coffee\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lWk0C1iwtegu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7802f1f6-d724-4656-8071-245857a3a204"
      },
      "source": [
        "m.offset"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uh1uc34etiN_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "602c83e5-391f-44e7-edb4-0f0d24bbdcd5"
      },
      "source": [
        "m = match(regex, \"A bit more tea?\")\n",
        "isnothing(m) && println(\"I suggest coffee instead\")"
      ],
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I suggest coffee instead\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3iOYSQMy0yB3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25255bcb-e35d-493a-9839-08d28aad2ddd"
      },
      "source": [
        "regex = r\"(.*)#(.+)\"\n",
        "line = \"f(1) # nice comment\"\n",
        "m = match(regex, line)\n",
        "code, comment = m.captures\n",
        "println(\"code: \", repr(code))\n",
        "println(\"comment: \", repr(comment))"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "code: \"f(1) \"\n",
            "comment: \" nice comment\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xeq9CVzoueaf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a98b407-f8b0-4bbf-e7db-1b0ef292ca72"
      },
      "source": [
        "m[2]"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\" nice comment\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iwUDm5uqtc73",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c5ec87ad-4c33-4caf-cd18-4e4291f9f61a"
      },
      "source": [
        "m.offsets"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2-element Vector{Int64}:\n",
              " 1\n",
              " 7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VnefZenKuMVM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d0a64a7c-cc44-46c7-b40d-f07a40a3db6b"
      },
      "source": [
        "m = match(r\"(?<code>.+)#(?<comment>.+)\", line)\n",
        "m[:comment]"
      ],
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\" nice comment\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HI8hBnXZwLIO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07be09bc-c12f-45f3-8206-4d59c1b6e46d"
      },
      "source": [
        "replace(\"Want more bread?\", r\"(?<verb>more|some)\" => s\"a little\")"
      ],
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Want a little bread?\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7V9msvsWuzSM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37205e00-3e65-40dd-9496-987c5be258c0"
      },
      "source": [
        "replace(\"Want more bread?\", r\"(?<verb>more|less)\" => s\"\\g<verb> and \\g<verb>\")"
      ],
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Want more and more bread?\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "56GuNuTqaKaX"
      },
      "source": [
        "# Control Flow"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AhlyD6rgHM-A"
      },
      "source": [
        "## `if` statement\n",
        "\n",
        "Julia's `if` statement works just like in Python, with a few differences:\n",
        "\n",
        "* Julia uses `elseif` instead of Python's `elif`.\n",
        "* Julia's logic operators are just like in C-like languages: `&&` means `and`, `||` means `or`, `!` means `not`, and so on."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R4CT1_AYLUqo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb23eca3-1b09-4db9-aa69-b619c6088076"
      },
      "source": [
        "a = 1\n",
        "if a == 1\n",
        "    println(\"One\")\n",
        "elseif a == 2\n",
        "    println(\"Two\")\n",
        "else\n",
        "    println(\"Other\")\n",
        "end"
      ],
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "One\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xjjegYr9Koo0"
      },
      "source": [
        "Julia also has `⊻` for exclusive or (you can type `\\xor<tab>` to get the ⊻ character):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ac0uFmmXLk3n"
      },
      "source": [
        "@assert false ⊻ false == false\n",
        "@assert false ⊻ true == true\n",
        "@assert true ⊻ false == true\n",
        "@assert true ⊻ true == false"
      ],
      "execution_count": 75,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6k6sjnOWLuFM"
      },
      "source": [
        "Oh, and notice that `true` and `false` are all lowercase, unlike Python's `True` and `False`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "57j5Uo_jKq98"
      },
      "source": [
        "Since `&&` is lazy (like `and` in Python), `cond && f()` is a common shorthand for `if cond; f(); end`. Think of it as \"_cond then f()_\":"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TjRz2LF2MC17",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "caf4d581-ce16-4b7e-c017-d0ba07acc100"
      },
      "source": [
        "a = 2\n",
        "a == 1 && println(\"One\")\n",
        "a == 2 && println(\"Two\")"
      ],
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Two\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PoOc99vdMB3r"
      },
      "source": [
        "Similarly, `cond || f()` is a common shorthand for `if !cond; f(); end`. Think of it as \"_cond else f()_\":"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I0vTrqXFMQAp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f14b684-a5f8-4919-aa15-f6788b58dbe7"
      },
      "source": [
        "a = 1\n",
        "a == 1 || println(\"Not one\")\n",
        "a == 2 || println(\"Not two\")"
      ],
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Not two\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KDHXuzB2tprt"
      },
      "source": [
        "All expressions return a value in Julia, including `if` statements. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XdbyrVzWtyYS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dd816a76-c6ed-4b6d-8a16-12f3d5d400ff"
      },
      "source": [
        "a = 1\n",
        "result = if a == 1\n",
        "             \"one\"\n",
        "         else\n",
        "             \"two\"\n",
        "         end\n",
        "result"
      ],
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"one\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ouJGQWRluC8r"
      },
      "source": [
        "When an expression cannot return anything, it returns `nothing`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FXxf9pNouMUZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8459b50e-13ec-4426-84a7-720d4f2543bf"
      },
      "source": [
        "a = 1\n",
        "result = if a == 2\n",
        "            \"two\"\n",
        "          end\n",
        "\n",
        "isnothing(result)"
      ],
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "82e9jcH4ukdN"
      },
      "source": [
        "`nothing` is the single instance of the type `Nothing`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IU57ogdWuhCi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0951150c-824c-4161-9967-4282527b09ab"
      },
      "source": [
        "typeof(nothing)"
      ],
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Nothing"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m8ghzU9PMifO"
      },
      "source": [
        "## `for` loops\n",
        "You can use `for` loops just like in Python, as we saw earlier. However, it's also possible to create nested loops on a single line:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LZ-3HDmZM45a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bfaa39fe-db6a-4b98-8175-26af978e6634"
      },
      "source": [
        "for a in 1:2, b in 1:3, c in 1:2\n",
        "    println((a, b, c))\n",
        "end"
      ],
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1, 1, 1)\n",
            "(1, 1, 2)\n",
            "(1, 2, 1)\n",
            "(1, 2, 2)\n",
            "(1, 3, 1)\n",
            "(1, 3, 2)\n",
            "(2, 1, 1)\n",
            "(2, 1, 2)\n",
            "(2, 2, 1)\n",
            "(2, 2, 2)\n",
            "(2, 3, 1)\n",
            "(2, 3, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uQRBca7fObQq"
      },
      "source": [
        "The corresponding Python code would look like this:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "from itertools import product\n",
        "\n",
        "for a, b, c in product(range(1, 3), range(1, 4), range(1, 3)):\n",
        "    print((a, b, c))\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JAeag3dfNRB3"
      },
      "source": [
        "The `continue` and `break` keywords work just like in Python. Note that in single-line nested loops, `break` will exit all loops, not just the inner loop:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MbKmgN-jN2ZQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "021165ce-c061-41d1-de54-68c0453e7d5a"
      },
      "source": [
        "for a in 1:2, b in 1:3, c in 1:2\n",
        "    println((a, b, c))\n",
        "    (a, b, c) == (2, 1, 1) && break\n",
        "end"
      ],
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1, 1, 1)\n",
            "(1, 1, 2)\n",
            "(1, 2, 1)\n",
            "(1, 2, 2)\n",
            "(1, 3, 1)\n",
            "(1, 3, 2)\n",
            "(2, 1, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lf7F9I-6Ue46"
      },
      "source": [
        "Julia does not support the equivalent of Python's `for`/`else` construct. You need to write something like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XltdIGVOUoVS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7cd15423-6911-4ccc-b054-450bd961620f"
      },
      "source": [
        "found = false\n",
        "for person in [\"Joe\", \"Jane\", \"Wally\", \"Jack\", \"Julia\"] # try removing \"Wally\"\n",
        "    println(\"Looking at $person\")\n",
        "    person == \"Wally\" && (found = true; break)\n",
        "end\n",
        "found || println(\"I did not find Wally.\")"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Looking at Joe\n",
            "Looking at Jane\n",
            "Looking at Wally\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ySqtkxpxWH57"
      },
      "source": [
        "The equivalent Python code looks like this:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "for person in [\"Joe\", \"Jane\", \"Wally\", \"Jack\", \"Julia\"]: # try removing \"Wally\"\n",
        "    print(f\"Looking at {person}\")\n",
        "    if person == \"Wally\":\n",
        "        break\n",
        "else:\n",
        "    print(\"I did not find Wally.\")\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gz4fZGxOHLmI"
      },
      "source": [
        "\n",
        "\n",
        "|Julia|Python\n",
        "|-----|------\n",
        "|`if cond1`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br/>`elseif cond2`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br/>`else`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br/>`end` |`if cond1:`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br/>`elif cond2:`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br/>`else:`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`\n",
        "|`&&` | `and`\n",
        "|`\\|\\|` | `or`\n",
        "|`!` | `not`\n",
        "|`⊻` (type `\\xor<tab>`) | `^`\n",
        "|`true` | `True`\n",
        "|`false` | `False`\n",
        "|`cond && f()` | `if cond: f()`\n",
        "|`cond \\|\\| f()` | `if not cond: f()`\n",
        "|`for i in 1:5 ... end` | `for i in range(1, 6): ...`\n",
        "|`for i in 1:5, j in 1:6 ... end` | `from itertools import product`<br />`for i, j in product(range(1, 6), range(1, 7)):`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`\n",
        "|`while cond ... end` | `while cond: ...`\n",
        "|`continue` | `continue`\n",
        "|`break` | `break`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KZnBWeHcvcDE"
      },
      "source": [
        "Now lets looks at data structures, starting with tuples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ERjZUJYlnMsq"
      },
      "source": [
        "# Tuples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LnIg-YKumD8N"
      },
      "source": [
        " Julia has tuples, very much like Python. They can contain anything:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SwtMszm6nFmD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "98cf0b47-23e8-482c-9706-1578ffda300a"
      },
      "source": [
        "t = (1, \"Two\", 3, 4, 5)"
      ],
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, \"Two\", 3, 4, 5)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YFGgt6ISLBQN"
      },
      "source": [
        "Let's look at one element:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "muUQX9TUnfhh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8cee6d0d-0ac0-4a1c-c2ab-e4d58d64a517"
      },
      "source": [
        "t[1]"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kxt7Dyujpcto"
      },
      "source": [
        "Hey! Did you see that? **Julia is 1-indexed**, like Matlab and other math-oriented programming languages, not 0-indexed like Python and most programming languages. I found it easy to get used to, and in fact I quite like it, but your mileage may vary.\n",
        "\n",
        "Moreover, the indexing bounds are inclusive. In Python, to get the 1st and 2nd elements of a list or tuple, you would write `t[0:2]` (or just `t[:2]`), while in Julia you write `t[1:2]`.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PSSUDRRtp77N",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1de6b799-2eab-4a8a-c690-59ec9d7c51fc"
      },
      "source": [
        "t[1:2]"
      ],
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, \"Two\")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gUK1aCRutlul"
      },
      "source": [
        "Note that `end` represents the index of the last element in the tuple. So you must write `t[end]` instead of `t[-1]`. Similarly, you must write `t[end - 1]`, not `t[-2]`, and so on."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7YpghPgLqZmy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a2b8d03b-cbed-4369-812e-34b6fc9e11d1"
      },
      "source": [
        "t[end]"
      ],
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3rzqwS7etsyx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2a019c2a-599b-420b-eb61-cf2ca0043d9d"
      },
      "source": [
        "t[end - 1:end]"
      ],
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4, 5)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d950dLwB3SeA"
      },
      "source": [
        "Like in Python, tuples are immutable:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0sLz7J2KmKMi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "010d7d2a-24ee-4d53-f30a-2e1694498469"
      },
      "source": [
        "try\n",
        "  t[2] = 2\n",
        "catch ex\n",
        "  ex\n",
        "end"
      ],
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MethodError(setindex!, ((1, \"Two\", 3, 4, 5), 2, 2), 0x00000000000073cf)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ia-7dPaYN6o3"
      },
      "source": [
        "The syntax for empty and 1-element tuples is the same as in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2iz34eBoODk6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "825f75f4-6025-4bc7-b1ff-05e84256bf60"
      },
      "source": [
        "empty_tuple = ()\n",
        "one_element_tuple = (42,)"
      ],
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(42,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4vgV76ftmMno"
      },
      "source": [
        "You can unpack a tuple, just like in Python (it's called \"destructuring\" in Julia):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1-RPxSCfn5Zr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "18fd4e45-0169-43ca-cf9b-a8711b1b6a37"
      },
      "source": [
        "a, b, c, d, e = (1, \"Two\", 3, 4, 5)\n",
        "println(\"a=$a, b=$b, c=$c, d=$d, e=$e\")"
      ],
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a=1, b=Two, c=3, d=4, e=5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I4jsaD4Fq37B"
      },
      "source": [
        "It also works with nested tuples, just like in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s3S4SAfNq83S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f6faf9b1-88f7-487c-8424-e578e24511a5"
      },
      "source": [
        "(a, (b, c), (d, e)) = (1, (\"Two\", 3), (4, 5))\n",
        "println(\"a=$a, b=$b, c=$c, d=$d, e=$e\")"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a=1, b=Two, c=3, d=4, e=5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1SC6AVpIrUxa"
      },
      "source": [
        "However, consider this example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wz5cl0_6rj0H",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3318d891-7807-458c-fbfd-f64a69e4461d"
      },
      "source": [
        "a, b, c = (1, \"Two\", 3, 4, 5)\n",
        "println(\"a=$a, b=$b, c=$c\")"
      ],
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a=1, b=Two, c=3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZdZg-xMDrnvK"
      },
      "source": [
        "In Python, this would cause a `ValueError: too many values to unpack`. In Julia, the extra values in the tuple are just ignored.\n",
        "\n",
        "If you want to capture the extra values in the variable `c`, you need to do so explicitly:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zC8DWzkSsF1i",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bb89ca02-334c-43d1-e7ca-9f2484317200"
      },
      "source": [
        "t = (1, \"Two\", 3, 4, 5)\n",
        "a, b = t[1:2]\n",
        "c = t[3:end]\n",
        "println(\"a=$a, b=$b, c=$c\")"
      ],
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a=1, b=Two, c=(3, 4, 5)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rOKhLbritHAW"
      },
      "source": [
        "Or more concisely:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Pvh4LCytCiq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2283cbd6-6f20-4caf-a3a0-bbd7d9970003"
      },
      "source": [
        "(a, b), c = t[1:2], t[3:end]\n",
        "println(\"a=$a, b=$b, c=$c\")"
      ],
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a=1, b=Two, c=(3, 4, 5)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FbibRKc9sWI_"
      },
      "source": [
        "The corresponding Python code is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "t = (1, \"Two\", 3, 4, 5)\n",
        "a, b, *c = t\n",
        "print(f\"a={a}, b={b}, c={c}\")\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "niHEbUJk5YFn"
      },
      "source": [
        "## Named Tuples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p3yVvsXA52ct"
      },
      "source": [
        "Julia supports named tuples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2FJnd4K35aOZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "879e000e-16a5-48fb-a71a-4ded4361895e"
      },
      "source": [
        "nt = (name=\"Julia\", category=\"Language\", stars=5)"
      ],
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(name = \"Julia\", category = \"Language\", stars = 5)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xydPCMQZ5sPY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f3b9540c-bf53-4632-ca79-ee99246f8ae4"
      },
      "source": [
        "nt.name"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Julia\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9MeN88AU5w4t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "69d823ed-6b08-4cbd-bcbe-c456ea52edcf"
      },
      "source": [
        "dump(nt)"
      ],
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "NamedTuple{(:name, :category, :stars), Tuple{String, String, Int64}}\n",
            "  name: String \"Julia\"\n",
            "  category: String \"Language\"\n",
            "  stars: Int64 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yXYEkJ0G57f2"
      },
      "source": [
        "The corresponding Python code is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "from collections import namedtuple\n",
        "\n",
        "Rating = namedtuple(\"Rating\", [\"name\", \"category\", \"stars\"])\n",
        "nt = Rating(name=\"Julia\", category=\"Language\", stars=5)\n",
        "print(nt.name) # prints: Julia\n",
        "print(nt) # prints: Rating(name='Julia', category='Language', stars=5)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MJFUxd06YdqY"
      },
      "source": [
        "# Structs\n",
        "Julia supports structs, which hold multiple named fields, a bit like named tuples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WhCs3HtJZK95"
      },
      "source": [
        "struct Person\n",
        "    name\n",
        "    age\n",
        "end"
      ],
      "execution_count": 99,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G5oQzSt9Zx3L"
      },
      "source": [
        "Structs have a default constructor, which expects all the field values, in order:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aXISSlv5Z8l6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a6fd6996-bd55-4bf6-f2bd-5620205c533d"
      },
      "source": [
        "p = Person(\"Mary\", 30)"
      ],
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Person(\"Mary\", 30)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "26v5EQ8YZ-JQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a815255f-75b4-49a4-a067-ae73d7d47b13"
      },
      "source": [
        "p.age"
      ],
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "30"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tq30l3f1dHcn"
      },
      "source": [
        "You can create other constructors by creating functions with the same name as the struct:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oS_GHuHpdPQx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e75ea05a-9886-425d-e6ed-208ec9919e3e"
      },
      "source": [
        "function Person(name)\n",
        "    Person(name, -1)\n",
        "end\n",
        "\n",
        "function Person()\n",
        "    Person(\"no name\")\n",
        "end\n",
        "\n",
        "p = Person()"
      ],
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Person(\"no name\", -1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MhHkPNXzeMwh"
      },
      "source": [
        "This creates two constructors: the second calls the first, which calls the default constructor. Notice that you can create multiple functions with the same name but different arguments. We will discuss this later."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C_qV3JIyeial"
      },
      "source": [
        "These two constructors are called \"outer constructors\", since they are defined outside of the definition of the struct. You can also define \"inner constructors\":"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XuGp8ZJJe13y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d97844b7-3574-494a-d858-977c052099ea"
      },
      "source": [
        "struct Person2\n",
        "    name\n",
        "    age\n",
        "    function Person2(name)\n",
        "        new(name, -1)\n",
        "    end\n",
        "end\n",
        "\n",
        "function Person2()\n",
        "    Person2(\"no name\")\n",
        "end\n",
        "\n",
        "p = Person2()"
      ],
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Person2(\"no name\", -1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m5qB9QHf1MMC"
      },
      "source": [
        "This time, the outer constructor calls the inner constructor, which calls the `new()` function. This `new()` function only works in inner constructors, and of course it creates an instance of the struct.\n",
        "\n",
        "When you define inner constructors, they replace the default constructor: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_xLhbC9q2vC3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "23526e87-efb4-4dd3-d773-d1fffb3b6840"
      },
      "source": [
        "try\n",
        "    Person2(\"Bob\", 40)\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MethodError(Person2, (\"Bob\", 40), 0x00000000000073d4)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6eSrsaNi_mQ3"
      },
      "source": [
        "Structs usually have very few inner constructors (often just one), which do the heavy duty work, and the checks. Then they may have multiple outer constructors which are mostly there for convenience."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HLJWvFSfaAHi"
      },
      "source": [
        "By default, structs are immutable:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n9hhxkdvaYOY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "68c1cb85-7000-4869-fc5c-e6a633a3be82"
      },
      "source": [
        "try\n",
        "    p.name = \"Someone\"\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 105,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ErrorException(\"setfield! immutable struct of type Person2 cannot be changed\")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oqY3EFMKa1Px"
      },
      "source": [
        "However, it is possible to define a mutable struct:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S5cNqzAma5H_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7eb775c0-2a99-4e9e-b05d-a92f4eeaa44b"
      },
      "source": [
        "mutable struct Person3\n",
        "    name\n",
        "    age\n",
        "end\n",
        "\n",
        "p = Person3(\"Lucy\", 79)\n",
        "p.age += 1\n",
        "p"
      ],
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Person3(\"Lucy\", 80)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XcMyQq4r7eam"
      },
      "source": [
        "Structs look a lot like Python classes, with instance variables and constructors, but where are the methods? We will discuss this later, in the \"Methods\" section."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sXEjDf7jBjJi"
      },
      "source": [
        "# Arrays\n",
        "\n",
        "Let's create a small array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UFhriSyixCMX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "94dbb4ce-53db-4166-cee9-cf5326c2178e"
      },
      "source": [
        "a = [1, 4, 9, 16]"
      ],
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "owVeZ9nLR2on"
      },
      "source": [
        "Indexing and assignments work as you would expect:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yM4mNBfKR81J",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "baf8aaf1-00b5-45fd-990e-910f43c3425d"
      },
      "source": [
        "a[1] = 10\n",
        "a[2:3] = [20, 30]\n",
        "a"
      ],
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              " 10\n",
              " 20\n",
              " 30\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bv_tPMOhxHtK"
      },
      "source": [
        "## Element Type\n",
        "Since we used only integers when creating the array, Julia inferred that the array is only meant to hold integers (NumPy arrays behave the same way). Let's try adding a string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XBiagA9b_YPR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b3c3624d-1695-4c4c-d39a-6fa15bc8d023"
      },
      "source": [
        "try\n",
        "  a[3] = \"Three\"\n",
        "catch ex\n",
        "  ex\n",
        "end"
      ],
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MethodError(convert, (Int64, \"Three\"), 0x00000000000073d5)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T8EJ7y5HAgzz"
      },
      "source": [
        "Nope! We get a `MethodError` exception, telling us that Julia could not convert the string `\"Three\"` to a 64-bit integer (we will discuss exceptions later). If we want an array that can hold any type, like Python's lists can, we must prefix the array with `Any`, which is Julia's root type (like `object` in Python):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VcsscYgVBX6Z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d218d37f-189c-495f-80d0-a2e05a2425e9"
      },
      "source": [
        "a = Any[1, 4, 9, 16]\n",
        "a[3] = \"Three\"\n",
        "a"
      ],
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Any}:\n",
              "  1\n",
              "  4\n",
              "   \"Three\"\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yekHWpLFPWUO"
      },
      "source": [
        "Prefixing with `Float64`, or `String` or any other type works as well:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hR9x5VEmPfgO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb1e481b-b1fb-4e83-cbc4-eb6f274290b6"
      },
      "source": [
        "Float64[1, 4, 9, 16]"
      ],
      "execution_count": 111,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Float64}:\n",
              "  1.0\n",
              "  4.0\n",
              "  9.0\n",
              " 16.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8-2ahduHoiRh"
      },
      "source": [
        "An empty array is automatically an `Any` array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eDMPVf5Oolnk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "83df0a4e-45e3-4b5c-e51a-aa5e410dd934"
      },
      "source": [
        "a = []"
      ],
      "execution_count": 112,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Any[]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zY4m8VX2PmXq"
      },
      "source": [
        "You can use the `eltype()` function to get an array's element type (the equivalent of NumPy arrays' `dtype`):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zZN9rtpEPvGV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "67e644db-5103-4f5d-8b21-b8bd336982a2"
      },
      "source": [
        "eltype([1, 4, 9, 16])"
      ],
      "execution_count": 113,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 113
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RXavtfEvyx-I"
      },
      "source": [
        "If you create an array containing objects of different types, Julia will do its best to use a type that can hold all the values as precisely as possible. For example, a mix of integers and floats results in a float array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jovRNC9tzaWj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6d12cba5-c0c7-4963-ac8b-435cba93d6ef"
      },
      "source": [
        "[1, 2, 3.0, 4.0]"
      ],
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Float64}:\n",
              " 1.0\n",
              " 2.0\n",
              " 3.0\n",
              " 4.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z8vqDB0U0A4p"
      },
      "source": [
        "This is similar to NumPy's behavior:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "np.array([1, 2, 3.0, 4.0]) # => array([1., 2., 3., 4.])\n",
        "```\n",
        "\n",
        "A mix of unrelated types results in an `Any` array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pgT5mGcV0Rrc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d7342a25-0d86-449b-e084-3c1f251f968b"
      },
      "source": [
        "[1, 2, \"Three\", 4]"
      ],
      "execution_count": 115,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Any}:\n",
              " 1\n",
              " 2\n",
              "  \"Three\"\n",
              " 4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 115
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qqUknXIGB2r7"
      },
      "source": [
        "If you want to live in a world without type constraints, you can prefix all you arrays with `Any`, and you will feel like you're coding in Python. But I don't recommend it: the compiler can perform a bunch of optimizations when it knows exactly the type and size of the data the program will handle, so it will run much faster. So when you create an empty array but you know the type of the values it will contain, you might as well prefix it with that type (you don't have to, but it will speed up your program)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3oo7WzpiQB_h"
      },
      "source": [
        "## Push and Pop\n",
        "To append elements to an array, use the `push!()` function. By convention, functions whose name ends with a bang `!` may modify their arguments:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m2vQfFEVCxII",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e6efa11-7ff4-416f-e731-6540969012c3"
      },
      "source": [
        "a = [1]\n",
        "push!(a, 4)\n",
        "push!(a, 9, 16)"
      ],
      "execution_count": 116,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 116
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2U8zIXG-cUge"
      },
      "source": [
        "This is similar to the following Python code:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "a = [1]\n",
        "a.append(4)\n",
        "a.extend([9, 16]) # or simply a += [9, 16]\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CCWoFNINU15g"
      },
      "source": [
        "And `pop!()` works like in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ie0iAIHtSXIW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3c198e6-f468-44a1-d07e-55a0db5e0a3d"
      },
      "source": [
        "pop!(a)"
      ],
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0W67Y7JhVA3_"
      },
      "source": [
        "Equivalent to:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "a.pop()\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mY0L1GG_Upxz"
      },
      "source": [
        "There are many more functions you can call on an array. We will see later how to find them."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ZScNi5Rv8cM"
      },
      "source": [
        "## Multidimensional Arrays\n",
        "Importantly, Julia arrays can be multidimensional, just like NumPy arrays:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hxfUbTc3wBob",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4b7ef2d8-831c-45eb-b25f-3688141b8323"
      },
      "source": [
        "M = [1   2   3   4\n",
        "     5   6   7   8\n",
        "     9  10  11  12]"
      ],
      "execution_count": 118,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3×4 Matrix{Int64}:\n",
              " 1   2   3   4\n",
              " 5   6   7   8\n",
              " 9  10  11  12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sFlaq_4kwbde"
      },
      "source": [
        "Another syntax for this is:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wetBEg8HwhWJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "247d0e81-eab5-46d4-927b-61da1e2af15a"
      },
      "source": [
        "M = [1 2 3 4; 5 6 7 8; 9 10 11 12]"
      ],
      "execution_count": 119,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3×4 Matrix{Int64}:\n",
              " 1   2   3   4\n",
              " 5   6   7   8\n",
              " 9  10  11  12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 119
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "atfjWzUmwIgw"
      },
      "source": [
        "You can index them much like NumPy arrays:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GhtdjnYQwLka",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aa4989cf-6a96-4646-9931-c48e4f738b96"
      },
      "source": [
        "M[2:3, 3:4]"
      ],
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2×2 Matrix{Int64}:\n",
              "  7   8\n",
              " 11  12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 120
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4frazS3zXPQT"
      },
      "source": [
        "You can transpose a matrix using the \"adjoint\" operator `'`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ydWdJ1eFXVbJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6dbe8720-6e07-4b2e-ae7a-39d03df83d24"
      },
      "source": [
        "M'"
      ],
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4×3 adjoint(::Matrix{Int64}) with eltype Int64:\n",
              " 1  5   9\n",
              " 2  6  10\n",
              " 3  7  11\n",
              " 4  8  12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 121
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A032EIww_NsU"
      },
      "source": [
        "As you can see, Julia arrays are closer to NumPy arrays than to Python lists.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NnY2DL_YCPmZ"
      },
      "source": [
        "Arrays can be concatenated vertically using the `vcat()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pTazNcWZ_-8e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d81579f6-0df8-4e4e-ee23-05ac6cd307e0"
      },
      "source": [
        "M1 = [1 2\n",
        "      3 4]\n",
        "M2 = [5 6\n",
        "      7 8]\n",
        "vcat(M1, M2)"
      ],
      "execution_count": 122,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4×2 Matrix{Int64}:\n",
              " 1  2\n",
              " 3  4\n",
              " 5  6\n",
              " 7  8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 122
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GPjPb-cCCZI5"
      },
      "source": [
        "Alternatively, you can use the `[M1; M2]` syntax:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DOnN1wVOCp9z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5dd99a51-001b-493c-edde-d27775835bb0"
      },
      "source": [
        "[M1; M2]"
      ],
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4×2 Matrix{Int64}:\n",
              " 1  2\n",
              " 3  4\n",
              " 5  6\n",
              " 7  8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wvq9sUdOCtJR"
      },
      "source": [
        "To concatenate arrays horizontally, use `hcat()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xj7s5cedCLJy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "75ed6881-9975-44bf-eaf4-0df85e92ceaf"
      },
      "source": [
        "hcat(M1, M2)"
      ],
      "execution_count": 124,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2×4 Matrix{Int64}:\n",
              " 1  2  5  6\n",
              " 3  4  7  8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 124
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ciffAqpeC2dX"
      },
      "source": [
        "Or you can use the `[M1 M2]` syntax:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XxSWzDXhC08W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f0d63467-2d39-4345-9ae3-72848556cba2"
      },
      "source": [
        "[M1 M2]"
      ],
      "execution_count": 125,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2×4 Matrix{Int64}:\n",
              " 1  2  5  6\n",
              " 3  4  7  8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 125
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OhQoXAiyGge9"
      },
      "source": [
        "You can combine horizontal and vertical concatenation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ra4Xe-Cv_PKl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15587c81-ff88-4899-f692-912cac78b079"
      },
      "source": [
        "M3 = [9 10 11 12]\n",
        "[M1 M2; M3]"
      ],
      "execution_count": 126,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3×4 Matrix{Int64}:\n",
              " 1   2   5   6\n",
              " 3   4   7   8\n",
              " 9  10  11  12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 126
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sQllnyjlIBfB"
      },
      "source": [
        "Equivalently, you can call the `hvcat()` function. The first argument specifies the number of arguments to concatenate in each block row:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lv63KdpLEN4N",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "909b0965-cf79-40fc-98d0-cc3da522cadc"
      },
      "source": [
        "hvcat((2, 1), M1, M2, M3)"
      ],
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3×4 Matrix{Int64}:\n",
              " 1   2   5   6\n",
              " 3   4   7   8\n",
              " 9  10  11  12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e40Z6cdzWM2K"
      },
      "source": [
        "`hvcat()` is useful to create a single cell matrix:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KP-WjRlPzzSR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3edd3450-6709-4e82-bdc8-d9741cd6741c"
      },
      "source": [
        "hvcat(1, 42)"
      ],
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1×1 Matrix{Int64}:\n",
              " 42"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 128
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4xWYHOGgzvOr"
      },
      "source": [
        " Or a column vector (i.e., an _n_×1 matrix = a matrix with a single column):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NhVPed-TWW6b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dd96d09c-85bf-43ff-9ac3-992e8e1c5fab"
      },
      "source": [
        "hvcat((1, 1, 1), 10, 11, 12) # a column vector with values 10, 11, 12\n",
        "hvcat(1, 10, 11, 12) # equivalent to the previous line"
      ],
      "execution_count": 129,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3×1 Matrix{Int64}:\n",
              " 10\n",
              " 11\n",
              " 12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 129
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pVTtq2RyWfSD"
      },
      "source": [
        "Alternatively, you can transpose a row vector (but `hvcat()` is a bit faster):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9d8inKAGWjTr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37db88ba-3d4c-4db9-adf6-e04d0826a92b"
      },
      "source": [
        "[10 11 12]'"
      ],
      "execution_count": 130,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3×1 adjoint(::Matrix{Int64}) with eltype Int64:\n",
              " 10\n",
              " 11\n",
              " 12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 130
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f75W5yn5OiEC"
      },
      "source": [
        "The REPL and IJulia call `display()` to print the result of the last expression in a cell (except when it is `nothing`). It is fairly verbose:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9zTEV0mpOzm9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "0079a7cf-4795-4c90-97ef-2a7b0ff230ad"
      },
      "source": [
        "display([1, 2, 3, 4])"
      ],
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              " 1\n",
              " 2\n",
              " 3\n",
              " 4"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gMWooHYTO7NU"
      },
      "source": [
        "The `println()` function is more concise, but be careful not to confuse vectors, column vectors and row vectors (printed with commas, semi-colons and spaces, respectively):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xw2He_XbPQbz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "66619c16-c5e5-47cf-aec7-48c89f815674"
      },
      "source": [
        "println(\"Vector: \", [1, 2, 3, 4])\n",
        "println(\"Column vector: \", hvcat(1, 1, 2, 3, 4))\n",
        "println(\"Row vector: \", [1 2 3 4])\n",
        "println(\"Matrix: \", [1 2 3; 4 5 6])"
      ],
      "execution_count": 132,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Vector: [1, 2, 3, 4]\n",
            "Column vector: [1; 2; 3; 4]\n",
            "Row vector: [1 2 3 4]\n",
            "Matrix: [1 2 3; 4 5 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8yjMLNP2M3Ip"
      },
      "source": [
        "Although column vectors are printed as `[1; 2; 3; 4]`, evaluating `[1; 2; 3; 4]` will give you a regular vector. That's because `[x;y]` concatenates `x` and `y` vertically, and if `x` and `y` are scalars or vectors, you just get a regular vector."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bdnpqswqyrp8"
      },
      "source": [
        "|Julia|Python\n",
        "|-----|------\n",
        "|`a = [1, 2, 3]` | `a = [1, 2, 3]`<br />or<br />`import numpy as np`<br />`np.array([1, 2, 3])`\n",
        "|`a[1]` | `a[0]`\n",
        "|`a[end]` | `a[-1]`\n",
        "|`a[2:end-1]` | `a[1:-1]`\n",
        "|`push!(a, 5)` | `a.append(5)`\n",
        "|`pop!(a)` | `a.pop()`\n",
        "|`M = [1 2 3]` | `np.array([[1, 2, 3]])`\n",
        "|`M = [1 2 3]'` | `np.array([[1, 2, 3]]).T`\n",
        "|`M = hvcat(1,  1, 2, 3)` | `np.array([[1], [2], [3]])`\n",
        "|`M = [1 2 3`<br />&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;`4 5 6]`<br />or<br />`M = [1 2 3; 4 5 6]` | `M = np.array([[1,2,3], [4,5,6]])`\n",
        "|`M[1:2, 2:3]` | `M[0:2, 1:3]`\n",
        "|`[M1; M2]` | `np.r_[M1, M2]`\n",
        "|`[M1  M2]` | `np.c_[M1, M2]`\n",
        "|`[M1 M2; M3]` | `np.r_[np.c_[M1, M2], M3]`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "raewgAnU9YIv"
      },
      "source": [
        "## Comprehensions\n",
        "List comprehensions are available in Julia, just like in Python (they're usually just called \"comprehensions\" in Julia):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H8B6Tk429aTV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fc8c667c-6dfe-4755-ade5-6f7bc50f6619"
      },
      "source": [
        "a = [x^2 for x in 1:4]"
      ],
      "execution_count": 133,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 133
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1W4O8W3bQsIn"
      },
      "source": [
        "You can filter elements using an `if` clause, just like in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pK4bZX6LQzNF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3ea14799-c9f4-426f-c9e7-c8fab16b41d7"
      },
      "source": [
        "a = [x^2 for x in 1:5 if x ∉ (2, 4)]"
      ],
      "execution_count": 134,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3-element Vector{Int64}:\n",
              "  1\n",
              "  9\n",
              " 25"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 134
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E6UjXo-wRpdf"
      },
      "source": [
        "* `a ∉ b` is equivalent to `!(a in b)` (or `a not in b` in Python). You can type `∉` with `\\notin<tab>`\n",
        "* `a ∈ b` is equivalent to `a in b`. You can type it with `\\in<tab>`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6R3umUN4Qq1x"
      },
      "source": [
        "In Julia, comprehensions can contain nested loops, just like in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o7-yPeiSlY96",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7644d713-12bb-4444-f981-e82b38592ffe"
      },
      "source": [
        "a = [(i,j) for i in 1:3 for j in 1:i]"
      ],
      "execution_count": 135,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6-element Vector{Tuple{Int64, Int64}}:\n",
              " (1, 1)\n",
              " (2, 1)\n",
              " (2, 2)\n",
              " (3, 1)\n",
              " (3, 2)\n",
              " (3, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 135
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tgmDLO9-ljg2"
      },
      "source": [
        "Here's the corresponding Python code:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "a = [(i, j) for i in range(1, 4) for j in range(1, i+1)]\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1d06vVpLi9pS"
      },
      "source": [
        "Julia comprehensions can also create multi-dimensional arrays (note the different syntax: there is only one `for`):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gx9M3oLFjHsp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3d40307b-536a-4fcb-bc21-f3455e4934cd"
      },
      "source": [
        "a = [row * col for row in 1:3, col in 1:5]"
      ],
      "execution_count": 136,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3×5 Matrix{Int64}:\n",
              " 1  2  3   4   5\n",
              " 2  4  6   8  10\n",
              " 3  6  9  12  15"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 136
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8_MgIEMeg69D"
      },
      "source": [
        "# Dictionaries\n",
        "The syntax for dictionaries is a bit different than Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IwBc2os7g9Yr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eb2dc8ff-8a0a-4fe6-84e3-db67ad7f9499"
      },
      "source": [
        "d = Dict(\"tree\"=>\"arbre\", \"love\"=>\"amour\", \"coffee\"=>\"café\")\n",
        "println(d[\"tree\"])"
      ],
      "execution_count": 137,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "arbre\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rZoY383Qhaus",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f366e34f-81ab-4db8-e84c-e23117cdc11b"
      },
      "source": [
        "println(get(d, \"unknown\", \"pardon?\"))"
      ],
      "execution_count": 138,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "pardon?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GOk28cgEjsjG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f0a7cd43-539e-4d05-fca9-e4811520b280"
      },
      "source": [
        "keys(d)"
      ],
      "execution_count": 139,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KeySet for a Dict{String, String} with 3 entries. Keys:\n",
              "  \"coffee\"\n",
              "  \"tree\"\n",
              "  \"love\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 139
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xrt3-wu7j6TI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "671fc235-0656-4fa8-b9be-bd26d171a077"
      },
      "source": [
        "values(d)"
      ],
      "execution_count": 140,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ValueIterator for a Dict{String, String} with 3 entries. Values:\n",
              "  \"café\"\n",
              "  \"arbre\"\n",
              "  \"amour\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 140
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J2kRT8MGj8Wo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ad6e9e54-efb9-4bf8-8eda-f3fa041eb586"
      },
      "source": [
        "haskey(d, \"love\")"
      ],
      "execution_count": 141,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 141
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PABOOmVSkJ6l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0bde0f53-4e15-4232-f8dc-8bfab4a1c940"
      },
      "source": [
        "\"love\" in keys(d) # this is slower than haskey()"
      ],
      "execution_count": 142,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 142
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xfL2ZXK6hlEt"
      },
      "source": [
        "The equivalent Python code is of course:\n",
        "\n",
        "```python\n",
        "d = {\"tree\": \"arbre\", \"love\": \"amour\", \"coffee\": \"café\"}\n",
        "d[\"tree\"]\n",
        "d.get(\"unknown\", \"pardon?\")\n",
        "d.keys()\n",
        "d.values()\n",
        "\"love\" in d\n",
        "\"love\" in d.keys()\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8MI_Oti4h2sz"
      },
      "source": [
        "Dict comprehensions work as you would expect:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ck21M2RIiEWw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e44b6e3d-dee4-4d3d-e447-5bc266c2c554"
      },
      "source": [
        "d = Dict(i=>i^2 for i in 1:5)"
      ],
      "execution_count": 143,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Dict{Int64, Int64} with 5 entries:\n",
              "  5 => 25\n",
              "  4 => 16\n",
              "  2 => 4\n",
              "  3 => 9\n",
              "  1 => 1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 143
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yeyP5pbQiK4-"
      },
      "source": [
        "Note that the items (aka \"pairs\" in Julia) are shuffled, since dictionaries are hash-based, like in Python (although Python sorts them by key for display).\n",
        "\n",
        "You can easily iterate through the dictionary's pairs like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GJ1PcdDHiouw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e5aaeeac-bd7c-45e4-d4e7-c49e9ee4ece2"
      },
      "source": [
        "for (k, v) in d\n",
        "    println(\"$k maps to $v\")\n",
        "end"
      ],
      "execution_count": 144,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5 maps to 25\n",
            "4 maps to 16\n",
            "2 maps to 4\n",
            "3 maps to 9\n",
            "1 maps to 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oSjOvDGxi-DS"
      },
      "source": [
        "The equivalent code in Python is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "d = {i: i**2 for i in range(1, 6)}\n",
        "for k, v in d.items():\n",
        "    print(f\"{k} maps to {v}\")\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b5Ea2USET5jD"
      },
      "source": [
        "And you can merge dictionaries like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dkNkluLJT7zD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f60ab612-ebc7-49a6-abc3-189ff2a4957b"
      },
      "source": [
        "d1 = Dict(\"tree\"=>\"arbre\", \"love\"=>\"amour\", \"coffee\"=>\"café\")\n",
        "d2 = Dict(\"car\"=>\"voiture\", \"love\"=>\"aimer\")\n",
        "\n",
        "d = merge(d1, d2)"
      ],
      "execution_count": 145,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Dict{String, String} with 4 entries:\n",
              "  \"car\"    => \"voiture\"\n",
              "  \"coffee\" => \"café\"\n",
              "  \"tree\"   => \"arbre\"\n",
              "  \"love\"   => \"aimer\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 145
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B1WRTtDXUSCt"
      },
      "source": [
        "Notice that the second dictionary has priority in case of conflict (it's `\"love\" => \"aimer\"`, not `\"love\" => \"amour\"`)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vpIXgc-4Umc8"
      },
      "source": [
        "In Python, this would be:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "d1 = {\"tree\": \"arbre\", \"love\": \"amour\", \"coffee\": \"café\"}\n",
        "d2 = {\"car\": \"voiture\", \"love\": \"aimer\"}\n",
        "d = {**d1, **d2}\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zu39af1MVaKB"
      },
      "source": [
        "Or if you want to update the first dictionary instead of creating a new one:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5_kcU7WTVhIN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aa074b1d-3c93-400f-d801-02d97ff90209"
      },
      "source": [
        "merge!(d1, d2)"
      ],
      "execution_count": 146,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Dict{String, String} with 4 entries:\n",
              "  \"car\"    => \"voiture\"\n",
              "  \"coffee\" => \"café\"\n",
              "  \"tree\"   => \"arbre\"\n",
              "  \"love\"   => \"aimer\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 146
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9h_NjAmAVmBd"
      },
      "source": [
        "In Python, that's:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "d1.update(d2)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6_-ibdMnjP8a"
      },
      "source": [
        "In Julia, each pair is an actual `Pair` object:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a85m1lmJjVPP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3c1d9b8e-baf2-43ad-f202-84f647946a5d"
      },
      "source": [
        "p = \"tree\" => \"arbre\"\n",
        "println(typeof(p))\n",
        "k, v = p\n",
        "println(\"$k maps to $v\")"
      ],
      "execution_count": 147,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Pair{String, String}\n",
            "tree maps to arbre\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mOCYFiB3N5s8"
      },
      "source": [
        "Note that any object for which a `hash()` method is implemented can be used as a key in a dictionary. This includes all the basic types like integers, floats, as well as string, tuples, etc. But it also includes arrays! In Julia, you have the freedom to use arrays as keys (unlike in Python), but make sure not to mutate these arrays after insertion, or else things will break! Indeed, the pairs will be stored in memory in a location that depends on the hash of the key at insertion time, so if that key changes afterwards, you won't be able to find the pair anymore:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0bYNOLHiOgnl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4383413c-1204-4a6c-fb80-2be92e29625f"
      },
      "source": [
        "a = [1, 2, 3]\n",
        "d = Dict(a => \"My array\")\n",
        "println(\"The dictionary is: $d\")\n",
        "println(\"Indexing works fine as long as the array is unchanged: \", d[a])\n",
        "a[1] = 10\n",
        "println(\"This is the dictionary now: $d\")\n",
        "try\n",
        "    println(\"Key changed, indexing is now broken: \", d[a])\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 148,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The dictionary is: Dict([1, 2, 3] => \"My array\")\n",
            "Indexing works fine as long as the array is unchanged: My array\n",
            "This is the dictionary now: Dict([10, 2, 3] => \"My array\")\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "KeyError([10, 2, 3])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 148
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zr26SHedQJTE"
      },
      "source": [
        "However, it's still possible to iterate through the keys, the values or the pairs:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5e6eZEq9QUt4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5ffa044e-99cf-4547-da62-00b1c72ce5cb"
      },
      "source": [
        "for pair in d\n",
        "    println(pair)\n",
        "end"
      ],
      "execution_count": 149,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10, 2, 3] => \"My array\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ie9QcVsYWDFh"
      },
      "source": [
        "|Julia|Python\n",
        "|-----|------\n",
        "|`Dict(\"tree\"=>\"arbre\", \"love\"=>\"amour\")` | `{\"tree\": \"arbre\", \"love\": \"amour\"}`\n",
        "|`d[\"arbre\"]` | `d[\"arbre\"]`\n",
        "|`get(d, \"unknown\", \"default\")` | `d.get(\"unknown\", \"default\")`\n",
        "|`keys(d)` | `d.keys()`\n",
        "|`values(d)` | `d.values()`\n",
        "|`haskey(d, k)` | `k in d`\n",
        "|`Dict(i=>i^2 for i in 1:4)` | `{i: i**2 for i in 1:4}`\n",
        "|`for (k, v) in d` | `for k, v in d.items():`\n",
        "|`merge(d1, d2)` | `{**d1, **d2}`\n",
        "|`merge!(d1, d2)` | `d1.update(d2)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rTWmi1P8jlDq"
      },
      "source": [
        "# Sets"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WlTKQaxxmLde"
      },
      "source": [
        "Let's create a couple sets:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sQ_wNw0Mjmqs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4afc22d0-9594-423a-e471-cc8906d334fd"
      },
      "source": [
        "odd = Set([1, 3, 5, 7, 9, 11])\n",
        "prime = Set([2, 3, 5, 7, 11])"
      ],
      "execution_count": 150,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Set{Int64} with 5 elements:\n",
              "  5\n",
              "  7\n",
              "  2\n",
              "  11\n",
              "  3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 150
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w7JZBRWbsqiL"
      },
      "source": [
        "The order of sets is not guaranteed, just like in Python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JEQ96Ljkm_0R"
      },
      "source": [
        "Use `in` or `∈` (type `\\in<tab>`) to check whether a set contains a given value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oRd2gpWvm9mF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d2b126a3-4f66-49d2-df40-62a5e51bc09d"
      },
      "source": [
        "5 ∈ odd"
      ],
      "execution_count": 151,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 151
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pRQN8XNWnQgj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15431eaf-598e-4ac2-8694-d6789cdc840b"
      },
      "source": [
        "5 in odd"
      ],
      "execution_count": 152,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 152
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WyBv6ethnRw8"
      },
      "source": [
        "Both of these expressions are equivalent to:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Twamj50pnXQE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f452f62f-6c45-42b3-f46d-87a4f708ab62"
      },
      "source": [
        "in(5, odd)"
      ],
      "execution_count": 153,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 153
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MHQ5qnLZmPhR"
      },
      "source": [
        "Now let's get the union of these two sets:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mfuMOXDdmGKA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "00b196f4-96fe-403a-de63-235468b87e86"
      },
      "source": [
        "odd ∪ prime"
      ],
      "execution_count": 154,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Set{Int64} with 7 elements:\n",
              "  5\n",
              "  7\n",
              "  1\n",
              "  11\n",
              "  2\n",
              "  9\n",
              "  3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 154
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xS6GLhE5mRbD"
      },
      "source": [
        "∪ is the union symbol, not a U. To type this character, type `\\cup<tab>` (it has the shape of a cup). Alternatively, you can just use the `union()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G_yju4QvmerU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4bca1dbc-2e4e-4f96-9697-43153f332db5"
      },
      "source": [
        "union(odd, prime)"
      ],
      "execution_count": 155,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Set{Int64} with 7 elements:\n",
              "  5\n",
              "  7\n",
              "  1\n",
              "  11\n",
              "  2\n",
              "  9\n",
              "  3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 155
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y8l4331img0-"
      },
      "source": [
        "Now let's get the intersection using the ∩ symbol (type `\\cap<tab>`):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NazqlxbGmkZM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "986b3fd9-fe90-4a14-b1ca-8d0920f41e2f"
      },
      "source": [
        "odd ∩ prime"
      ],
      "execution_count": 156,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Set{Int64} with 4 elements:\n",
              "  5\n",
              "  7\n",
              "  11\n",
              "  3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 156
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X9-MDgxWmzXl"
      },
      "source": [
        "Or use the `intersect()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zcEEMfG4m1l9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c438ff94-0f95-41b8-a4b1-32a1b95a8a80"
      },
      "source": [
        "intersect(odd, prime)"
      ],
      "execution_count": 157,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Set{Int64} with 4 elements:\n",
              "  5\n",
              "  7\n",
              "  11\n",
              "  3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 157
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QSMs88owpLb2"
      },
      "source": [
        "Next, let's get the [set difference](https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement) and the [symetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) between these two sets:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Tpr5_BBpQH_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b5494e9f-fe9d-4c58-87ff-e7ef14072071"
      },
      "source": [
        "setdiff(odd, prime) # values in odd but not in prime"
      ],
      "execution_count": 158,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Set{Int64} with 2 elements:\n",
              "  9\n",
              "  1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 158
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "of_EQE1CpvpO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "91181c3a-87a8-42f2-f079-0d4e3ff518fc"
      },
      "source": [
        "symdiff(odd, prime) # values that are not in the intersection"
      ],
      "execution_count": 159,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Set{Int64} with 3 elements:\n",
              "  2\n",
              "  9\n",
              "  1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NH_-NbzPsSQ_"
      },
      "source": [
        "Lastly, set comprehensions work just fine:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LMIiE-0psXvs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f143cb8a-df79-49b1-a0fc-ab5e871930c4"
      },
      "source": [
        "Set([i^2 for i in 1:4])"
      ],
      "execution_count": 160,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Set{Int64} with 4 elements:\n",
              "  4\n",
              "  16\n",
              "  9\n",
              "  1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 160
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DBJ4XaVmoeUY"
      },
      "source": [
        "The equivalent Python code is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "odds = {1, 3, 5, 7, 9, 11}\n",
        "primes = {2, 3, 5, 7, 11}\n",
        "5 in primes\n",
        "odds | primes # union\n",
        "odds.union(primes)\n",
        "odds & primes # intersection\n",
        "odds.intersection(primes)\n",
        "odds - primes # set difference\n",
        "odds.difference(primes)\n",
        "odds ^ primes # symmetric difference\n",
        "odds.symmetric_difference(primes)\n",
        "{i**2 for i in range(1, 5)}\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vm1zWNsJRcFV"
      },
      "source": [
        "Note that you can store any hashable object in a `Set` (i.e., any instance of a type for which the `hash()` method is implemented). This includes arrays, unlike in Python. Just like for dictionary keys, you can add arrays to sets, but make sure not to mutate them after insertion."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nPrJ9Ih9X4ak"
      },
      "source": [
        "|Julia|Python\n",
        "|-----|------\n",
        "|`Set([1, 3, 5, 7])` | `{1, 3, 5, 7}`\n",
        "|`5 in odd` | `5 in odd`\n",
        "|`Set([i^2 for i in 1:4])` | `{i**2 for i in range(1, 5)}`\n",
        "|`odd ∪ primes` | `odd | primes`\n",
        "|`union(odd, primes)` | `odd.union(primes)`\n",
        "|`odd ∩ primes` | `odd & primes`\n",
        "|`insersect(odd, primes)` | `odd.intersection(primes)`\n",
        "|`setdiff(odd, primes)` | `odd - primes` or `odd.difference(primes)`\n",
        "|`symdiff(odd, primes)` | `odd ^ primes` or `odd.symmetric_difference(primes)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AOfz9B7ZF__1"
      },
      "source": [
        "# Enums"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RozBUdxsGgKv"
      },
      "source": [
        "To create an enum, use the `@enum` macro:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R6HMPDyvGB_k"
      },
      "source": [
        "@enum Fruit apple=1 banana=2 orange=3"
      ],
      "execution_count": 161,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dxFUJ9boGmkh"
      },
      "source": [
        "This creates the `Fruit` enum, with 3 possible values. It also binds the names to the values:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "czHDZ6MRGUvL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "49e43733-8323-472b-b7c1-7c390bd2c1f1"
      },
      "source": [
        "banana"
      ],
      "execution_count": 162,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "banana::Fruit = 2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 162
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ufyorAsGvzv"
      },
      "source": [
        "Or you can get a `Fruit` instance using the value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NVgfYUBWGObS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f115d60c-5a9b-4ca8-9d67-e32e81c45c7c"
      },
      "source": [
        "Fruit(2)"
      ],
      "execution_count": 163,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "banana::Fruit = 2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 163
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ctxEepMNG_-4"
      },
      "source": [
        "And you can get all the instances of the enum easily:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yPy9trwtGR1y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "72e94336-42f6-4b7f-8008-c3dc384fdd80"
      },
      "source": [
        "instances(Fruit)"
      ],
      "execution_count": 164,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(apple, banana, orange)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 164
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bBCsVIXEHD29"
      },
      "source": [
        "|Julia|Python\n",
        "|-----|------\n",
        "|`@enum Fruit apple=1 banana=2 orange=3` | `from enum import Enum`<br />`class Fruit(Enum):`<br />&nbsp;&nbsp;&nbsp;&nbsp;`APPLE = 1`<br />&nbsp;&nbsp;&nbsp;&nbsp;`BANANA = 2`<br />&nbsp;&nbsp;&nbsp;&nbsp;`ORANGE = 3`\n",
        "| `Fruit(2) === banana` | `Fruit(2) is Fruit.BANANA`\n",
        "| `instances(Fruit)` | `dir(Fruit)`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7OOe0m7pLj80"
      },
      "source": [
        "# Object Identity\n",
        "In the previous example, `Fruit(2)` and `banana` refer to the same object, not just two objects that happen to be equal. You can verify using the `===` operator, which is the equivalent of Python's `is` operator:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G6cpTrQcGUP4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6fd72407-fa77-424d-bc6b-a869c727ee21"
      },
      "source": [
        "banana === Fruit(2)"
      ],
      "execution_count": 165,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 165
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4QPR-8TeL5Wy"
      },
      "source": [
        "You can also check this by looking at their `objectid()`, which is the equivalent of Python's `id()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q6qYhWnyMBpf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8356e56a-b728-47cd-ed3b-60656e30a0f6"
      },
      "source": [
        "objectid(banana)"
      ],
      "execution_count": 166,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0x00000000fb8a3e87"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 166
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sT3hq8f_MEZN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f467b49a-d981-4295-daff-225730fbb766"
      },
      "source": [
        "objectid(Fruit(2))"
      ],
      "execution_count": 167,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0x00000000fb8a3e87"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 167
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4ZrS4322MKfN"
      },
      "source": [
        "a = [1, 2, 4]\n",
        "b = [1, 2, 4]\n",
        "@assert a == b  # a and b are equal\n",
        "@assert a !== b # but they are not the same object"
      ],
      "execution_count": 168,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K3EO6cQmMW0W"
      },
      "source": [
        "|Julia|Python\n",
        "|-----|------\n",
        "|`a === b` | `a is b`\n",
        "|`a !== b` | `a is not b`\n",
        "|`objectid(obj)` | `id(obj)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d_ATAuXREZx9"
      },
      "source": [
        "# Other Collections\n",
        "\n",
        "For the Julia equivalent of Python's other collections, namely `defaultdict`, `deque`, `OrderedDict`, and `Counter`, check out these libraries:\n",
        "\n",
        "* https://github.com/JuliaCollections/DataStructures.jl\n",
        "* https://github.com/JuliaCollections/OrderedCollections.jl\n",
        "* https://github.com/andyferris/Dictionaries.jl"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GBYBDAsF6iDC"
      },
      "source": [
        "Now let's looks at various iteration constructs."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jApml2wDacs2"
      },
      "source": [
        "# Iteration Tools"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AW2vVurj9E7r"
      },
      "source": [
        "## Generator Expressions\n",
        "\n",
        "Just like in Python, a generator expression resembles a list comprehension, but without the square brackets, and it returns a generator instead of a list. Here's a much shorter implementation of the `estimate_pi()` function using a generator expression:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7pLMhQjV6z5l"
      },
      "source": [
        "function estimate_pi2(n)\n",
        "    4 * sum((isodd(i) ? -1 : 1)/(2i+1) for i in 0:n)\n",
        "end\n",
        "\n",
        "@assert estimate_pi(100) == estimate_pi2(100)"
      ],
      "execution_count": 169,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u-WAtc-eDcp9"
      },
      "source": [
        "That's very similar to the corresponding Python code:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "def estimate_pi2(n):\n",
        "  return 4 * sum((-1 if i%2==1 else 1)/(2*i+1) for i in range(n+1))\n",
        "\n",
        "assert estimate_pi(100) == estimate_pi2(100)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OHaPPceEKO3r"
      },
      "source": [
        "## `zip`, `enumerate`, `collect`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GBj2mvbiI9cP"
      },
      "source": [
        "The `zip()` function works much like in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-UsOasVeJCWe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "91ec878d-7c2c-42e1-ed32-ff321aa60241"
      },
      "source": [
        "for (i, s) in zip(10:13, [\"Ten\", \"Eleven\", \"Twelve\"])\n",
        "    println(i, \": \", s)\n",
        "end"
      ],
      "execution_count": 170,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10: Ten\n",
            "11: Eleven\n",
            "12: Twelve\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hu_eJ7okKolh"
      },
      "source": [
        "Notice that the parentheses in `for (i, s)` are required in Julia, as opposed to Python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3y2q4YhNJOQy"
      },
      "source": [
        "The `enumerate()` function also works like in Python, except of course it is 1-indexed:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bCTejeu0Ji_8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "61c792ad-ed09-46b8-9813-b6828420d880"
      },
      "source": [
        "for (i, s) in enumerate([\"One\", \"Two\", \"Three\"])\n",
        "    println(i, \": \", s)\n",
        "end"
      ],
      "execution_count": 171,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1: One\n",
            "2: Two\n",
            "3: Three\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vs4_UjWnJy20"
      },
      "source": [
        "To pull the values of a generator into an array, use `collect()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "42T1NJKhKD1w",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8d459d28-7785-4edf-93aa-372a4ab1fe10"
      },
      "source": [
        "collect(1:5)"
      ],
      "execution_count": 172,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5-element Vector{Int64}:\n",
              " 1\n",
              " 2\n",
              " 3\n",
              " 4\n",
              " 5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 172
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MQMx3bjkKFpk"
      },
      "source": [
        "A shorter syntax for that is:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2IEoo_TvKIDm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "929102d1-7f8f-4ab5-e85d-00b884e941df"
      },
      "source": [
        "[1:5;]"
      ],
      "execution_count": 173,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5-element Vector{Int64}:\n",
              " 1\n",
              " 2\n",
              " 3\n",
              " 4\n",
              " 5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 173
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gbub1jhlKc0V"
      },
      "source": [
        "The equivalent Python code is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "list(range(1, 6))\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CumclAQ4TTpq"
      },
      "source": [
        "## Generators\n",
        "In Python, you can easily write a generator function to create an object that will behave like an iterator. For example, let's create a generator for the Fibonacci sequence (where each number is the sum of the two previous numbers):\n",
        "\n",
        "```python\n",
        "def fibonacci(n):\n",
        "    a, b = 1, 1\n",
        "    for i in range(n):\n",
        "      yield a\n",
        "      a, b = b, a + b\n",
        "\n",
        "for f in fibonacci(10):\n",
        "    print(f)\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bfjsba6gFcMS"
      },
      "source": [
        "This is also quite easy in Julia:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cQZ0cowPUC8x",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c2c0fdba-3e1b-4008-acbe-6fd049fb6b40"
      },
      "source": [
        "function fibonacci(n)\n",
        "    Channel() do ch\n",
        "        a, b = 1, 1\n",
        "        for i in 1:n\n",
        "            put!(ch, a)\n",
        "            a, b = b, a + b\n",
        "        end\n",
        "    end\n",
        "end\n",
        "\n",
        "for f in fibonacci(10)\n",
        "    println(f)\n",
        "end"
      ],
      "execution_count": 174,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n",
            "55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VWkUE9FRFfQI"
      },
      "source": [
        "The `Channel` type is part of the API for tasks and coroutines. We'll discuss these later."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lisTUktNlbQt"
      },
      "source": [
        "Now let's take a closer look at functions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jKpjTHMbao6r"
      },
      "source": [
        "# Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k-IIQF4vP7w9"
      },
      "source": [
        "## Arguments\n",
        "Julia functions supports positional arguments and default values:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BnVg7UKNQQ4M",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ce34061-5c68-487a-f5a9-72e5333baf83"
      },
      "source": [
        "function draw_face(x, y, width=3, height=4)\n",
        "    println(\"x=$x, y=$y, width=$width, height=$height\")\n",
        "end\n",
        "\n",
        "draw_face(10, 20, 30)"
      ],
      "execution_count": 175,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x=10, y=20, width=30, height=4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AmKSe9fYRMxb"
      },
      "source": [
        "However, unlike in Python, positional arguments must not be named when the function is called:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fB1flNxMRAo4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a1a4b7e4-47a1-4d86-d9bf-e879ee313c33"
      },
      "source": [
        "try\n",
        "    draw_face(10, 20, width=30)\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 176,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MethodError(var\"#draw_face##kw\"(), ((width = 30,), draw_face, 10, 20), 0x00000000000073e9)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 176
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yBQOd8H6RUJs"
      },
      "source": [
        "Julia also supports a variable number of arguments (called \"varargs\") using the syntax `arg...`, which is the equivalent of Python's `*arg`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OS1U6AxeRYyb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dbdf9585-4257-46d3-cf09-48fadb5e855e"
      },
      "source": [
        "function copy_files(target_dir, paths...)\n",
        "    println(\"target_dir=$target_dir, paths=$paths\")\n",
        "end\n",
        "\n",
        "copy_files(\"/tmp\", \"a.txt\", \"b.txt\")"
      ],
      "execution_count": 177,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "target_dir=/tmp, paths=(\"a.txt\", \"b.txt\")\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x8lJsP6wQujj"
      },
      "source": [
        "Keyword arguments are supported, after a semicolon `;`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R4XDHjftQwel",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "34b10e15-44f6-413a-f90a-b0fe73abdb3d"
      },
      "source": [
        "function copy_files2(paths...; confirm=false, target_dir)\n",
        "    println(\"paths=$paths, confirm=$confirm, $target_dir\")\n",
        "end\n",
        "\n",
        "copy_files2(\"a.txt\", \"b.txt\"; target_dir=\"/tmp\")"
      ],
      "execution_count": 178,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "paths=(\"a.txt\", \"b.txt\"), confirm=false, /tmp\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "katU7ZypHZdc"
      },
      "source": [
        "Notes:\n",
        "* `target_dir` has no default value, so it is a required argument.\n",
        "* The order of the keyword arguments does not matter."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c24CyL7PGE35"
      },
      "source": [
        "You can have another vararg in the keyword section. It corresponds to Python's `**kwargs`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m-u29GPoGP8l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b8d658d2-ef64-4553-9200-5230214e905b"
      },
      "source": [
        "function copy_files3(paths...; confirm=false, target_dir, options...)\n",
        "    println(\"paths=$paths, confirm=$confirm, $target_dir\")\n",
        "    verbose = options[:verbose]\n",
        "    println(\"verbose=$verbose\")\n",
        "end\n",
        "\n",
        "copy_files3(\"a.txt\", \"b.txt\"; target_dir=\"/tmp\", verbose=true, timeout=60)"
      ],
      "execution_count": 179,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "paths=(\"a.txt\", \"b.txt\"), confirm=false, /tmp\n",
            "verbose=true\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UpbuZ0RYGsC2"
      },
      "source": [
        "The `options` vararg acts like a dictionary (we will discuss dictionaries later). The keys are **symbols**, e.g., `:verbose`. Symbols are like strings, less flexible but faster. They are typically used as keys or identifiers.\n",
        "\n",
        "|Julia|Python (3.8+ if `/` is used)\n",
        "|-----|------\n",
        "| `function foo(a, b=2, c=3)`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end`<br /><br />`foo(1, 2) # positional only` | `def foo(a, b=2, c=3, /):`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br /><br />`foo(1, 2) # pos only because of /`\n",
        "| `function foo(;a=1, b, c=3)`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end`<br /><br />`foo(c=30, b=2) # keyword only` | `def foo(*, a=1, b, c=3):`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br /><br />`foo(c=30, b=2) # kw only because of *`\n",
        "| `function foo(a, b=2; c=3, d)`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end`<br /><br />`foo(1; d=4) # pos only; then keyword only` | `def foo(a, b=2, /, *, c=3, d):`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br /><br />`foo(1, d=4) # pos only then kw only`\n",
        "| `function foo(a, b=2, c...)`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end`<br /><br />`foo(1, 2, 3, 4) # positional only` | `def foo(a, b=2, /, *c):`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br /><br />`foo(1, 2, 3, 4) # positional only`\n",
        "| `function foo(a, b=1, c...; d=1, e, f...)`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end`<br /><br />`foo(1, 2, 3, 4, e=5, x=10, y=20)`<br /> | `def foo(a, b=1, /, *c, d=1, e, **f):`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br /><br />`foo(1, 2, 3, 4, e=5, x=10, y=20)`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JQsdtaYXDoNm"
      },
      "source": [
        "## Concise Functions\n",
        "\n",
        "In Julia, the following definition:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PnB4hMDIkd_4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a39dfb82-d96d-44bc-acff-7f981cf7dcca"
      },
      "source": [
        "square(x) = x^2"
      ],
      "execution_count": 180,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "square (generic function with 1 method)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 180
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iXKsRqZUkk9O"
      },
      "source": [
        "is equivalent to:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iaDlQ7Mzkong",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ba240ba0-c8a2-4eea-d85b-fbb2724bb3ae"
      },
      "source": [
        "function square(x)\n",
        "    x^2\n",
        "end"
      ],
      "execution_count": 181,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "square (generic function with 1 method)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 181
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fjt5CFRfktfK"
      },
      "source": [
        "For example, here's a shorter way to define the `estimate_pi()` function in Julia:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1_D5M-EFDymm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "91ad2719-d6b1-4b89-8ad0-60a79911c8e0"
      },
      "source": [
        "estimate_pi3(n) = 4 * sum((isodd(i) ? -1 : 1)/(2i+1) for i in 0:n)"
      ],
      "execution_count": 182,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "estimate_pi3 (generic function with 1 method)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 182
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZGDMqjmBls35"
      },
      "source": [
        "To define a function on one line in Python, you need to use a `lambda` (but this is generally frowned upon, since the resulting function's name is `\"<lambda>\"`):\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "square = lambda x: x**2\n",
        "assert square.__name__ == \"<lambda>\"\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pyLBXz8llVhu"
      },
      "source": [
        "This leads us to anonymous functions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UV29B5anEAFF"
      },
      "source": [
        "## Anonymous Functions\n",
        "Just like in Python, you can define anonymous functions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VAH0e6BjEJB2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6d2beb36-8fee-43f9-fac8-7ac30f708a75"
      },
      "source": [
        "map(x -> x^2, 1:4)"
      ],
      "execution_count": 183,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 183
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RLy4-8trawqM"
      },
      "source": [
        "Here is the equivalent Python code:\n",
        "\n",
        "```python\n",
        "list(map(lambda x: x**2, range(1, 5)))\n",
        "```\n",
        "\n",
        "Notes:\n",
        "* `map()` returns an array in Julia, instead of an iterator like in Python.\n",
        "* You could use a comprehension instead: `[x^2 for x in 1:4]`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7RcghJ-EEUjz"
      },
      "source": [
        "\n",
        "|Julia|Python\n",
        "|-----|------\n",
        "|`x -> x^2` | `lambda x: x**2`\n",
        "|`(x,y) -> x + y` | `lambda x,y: x + y `\n",
        "|`() -> println(\"yes\")` | `lambda: print(\"yes\")`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jSYEdqYvF6XH"
      },
      "source": [
        "In Python, lambda functions must be simple expressions. They cannot contain multiple statements. In Julia, they can be as long as you want. Indeed, you can create a multi-statement block using the syntax `(stmt_1; stmt_2; ...; stmt_n)`. The return value is the output of the last statement. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SnuJMFymEbPp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80a60021-dd04-4aa0-e2ab-26befeec0d83"
      },
      "source": [
        "map(x -> (println(\"Number $x\"); x^2), 1:4)"
      ],
      "execution_count": 184,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number 1\n",
            "Number 2\n",
            "Number 3\n",
            "Number 4\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 184
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k1ztQt-VGz7p"
      },
      "source": [
        "This syntax can span multiple lines:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H-XL-nysG67t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "43f086b2-388c-4df8-f21b-816694404ac3"
      },
      "source": [
        "map(x -> (\n",
        "  println(\"Number $x\");\n",
        "  x^2), 1:4)"
      ],
      "execution_count": 185,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number 1\n",
            "Number 2\n",
            "Number 3\n",
            "Number 4\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 185
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YZUU9OLdHEUX"
      },
      "source": [
        "But in this case, it's probably clearer to use the `begin ... end` syntax instead:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t3LUgpigHJ3Z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "38d42ee4-0760-489c-dac1-34c3e913e23a"
      },
      "source": [
        "map(x -> begin\n",
        "        println(\"Number $x\")\n",
        "        x^2\n",
        "    end, 1:4)"
      ],
      "execution_count": 186,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number 1\n",
            "Number 2\n",
            "Number 3\n",
            "Number 4\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 186
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FQ5nX-AHIYUr"
      },
      "source": [
        "Notice that this syntax allows you to drop the semicolons `;` at the end of each line in the block.\n",
        "\n",
        "Yet another way to define an anonymous function is using the `function (args) ... end` syntax:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vKAR1ucxIQzF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bc0f0ab0-0a10-4d9d-eb56-7e16f2d890a7"
      },
      "source": [
        "map(function (x)\n",
        "        println(\"Number $x\")\n",
        "        x^2\n",
        "    end, 1:4)"
      ],
      "execution_count": 187,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number 1\n",
            "Number 2\n",
            "Number 3\n",
            "Number 4\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 187
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SGBwAWJ7HQ78"
      },
      "source": [
        "Lastly, if you're passing the anonymous function as the first argument to a function (as is the case in this example), it's usually much preferable to define the anonymous function immediately after the function call, using the `do` syntax, like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G60xP30UHW5F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bb032f19-03d9-407b-862b-931f69dd0254"
      },
      "source": [
        "map(1:4) do x\n",
        "  println(\"Number $x\")\n",
        "  x^2\n",
        "end"
      ],
      "execution_count": 188,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number 1\n",
            "Number 2\n",
            "Number 3\n",
            "Number 4\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 188
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vtsXFsLTJTpD"
      },
      "source": [
        "This syntax lets you easily define constructs that feel like language extensions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "03Hru6aqIIgY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e45ca426-0640-44fe-e2f6-4aa4f697adbe"
      },
      "source": [
        "function my_for(func, collection)\n",
        "    for i in collection\n",
        "        func(i)\n",
        "    end\n",
        "end\n",
        "\n",
        "my_for(1:4) do i\n",
        "    println(\"The square of $i is $(i^2)\")\n",
        "end"
      ],
      "execution_count": 189,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The square of 1 is 1\n",
            "The square of 2 is 4\n",
            "The square of 3 is 9\n",
            "The square of 4 is 16\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tFWXrW9z9q8f"
      },
      "source": [
        "In fact, Julia has a similar `foreach()` function."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XXuNr-9iZJf4"
      },
      "source": [
        "The `do` syntax could be used to write a Domain Specific Language (DSL), for example an infrastructure automation DSL:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sF1f2HsCZKoT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ebd8761-989b-4bb4-ce2e-2ba048504049"
      },
      "source": [
        "function spawn_server(startup_func, server_type)\n",
        "    println(\"Starting $server_type server\")\n",
        "    server_id = 1234\n",
        "    println(\"Configuring server $server_id...\")\n",
        "    startup_func(server_id)\n",
        "end\n",
        "\n",
        "# This is the DSL part\n",
        "spawn_server(\"web\") do server_id\n",
        "    println(\"Creating HTML pages on server $server_id...\")\n",
        "end"
      ],
      "execution_count": 190,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Starting web server\n",
            "Configuring server 1234...\n",
            "Creating HTML pages on server 1234...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9jRtJFU82wEO"
      },
      "source": [
        "It's also quite nice for event-driven code:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lU-neWob2_As",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eba9f910-b3d8-4e6a-da0b-8eff371c04ed"
      },
      "source": [
        "handlers = []\n",
        "\n",
        "on_click(handler) = push!(handlers, handler)\n",
        "\n",
        "click(event) = foreach(handler->handler(event), handlers)\n",
        "\n",
        "on_click() do event\n",
        "    println(\"Mouse clicked at $event\")\n",
        "end\n",
        "\n",
        "on_click() do event\n",
        "    println(\"Beep.\")\n",
        "end\n",
        "\n",
        "click((x=50, y=20))\n",
        "click((x=120, y=10))"
      ],
      "execution_count": 191,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mouse clicked at (x = 50, y = 20)\n",
            "Beep.\n",
            "Mouse clicked at (x = 120, y = 10)\n",
            "Beep.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VclQwKNzajfP"
      },
      "source": [
        "It can also be used to create context managers, for example to automatically close an object after it has been used, even if an exception is raised:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_fCFbtHJarew",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1da27002-9525-4b0d-e3f2-c4435d90cc58"
      },
      "source": [
        "function with_database(func, name)\n",
        "    println(\"Opening connection to database $name\")\n",
        "    db = \"a db object for database $name\"\n",
        "    try\n",
        "        func(db)\n",
        "    finally\n",
        "        println(\"Closing connection to database $name\")\n",
        "    end\n",
        "end\n",
        "\n",
        "with_database(\"jobs\") do db\n",
        "    println(\"I'm working with $db\")\n",
        "    #error(\"Oops\") # try uncommenting this line\n",
        "end"
      ],
      "execution_count": 192,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Opening connection to database jobs\n",
            "I'm working with a db object for database jobs\n",
            "Closing connection to database jobs\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D17bqrJwbqS5"
      },
      "source": [
        "The equivalent code in Python would look like this:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YmCiwD0Ubslm"
      },
      "source": [
        "```python\n",
        "# PYTHON\n",
        "class Database:\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "    def __enter__(self):\n",
        "        print(f\"Opening connection to database {self.name}\")\n",
        "        return f\"a db object for database {self.name}\"\n",
        "    def __exit__(self, type, value, traceback):\n",
        "        print(f\"Closing connection to database {self.name}\")\n",
        "\n",
        "with Database(\"jobs\") as db:\n",
        "    print(f\"I'm working with {db}\")\n",
        "    #raise Exception(\"Oops\") # try uncommenting this line\n",
        "```\n",
        "\n",
        "Or you could use `contextlib`:\n",
        "\n",
        "```python\n",
        "from contextlib import contextmanager\n",
        "\n",
        "@contextmanager\n",
        "def database(name):\n",
        "    print(f\"Opening connection to database {name}\")\n",
        "    db = f\"a db object for database {name}\"\n",
        "    try:\n",
        "        yield db\n",
        "    finally:\n",
        "        print(f\"Closing connection to database {name}\")\n",
        "\n",
        "with database(\"jobs\") as db:\n",
        "    print(f\"I'm working with {db}\")\n",
        "    #raise Exception(\"Oops\") # try uncommenting this line\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NA9wxvDP444S"
      },
      "source": [
        ""
      ],
      "execution_count": 193,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "scEsYrSt2jpA"
      },
      "source": [
        "## Piping\n",
        "If you are used to the Object Oriented syntax `\"a b c\".upper().split()`, you may feel that writing `split(uppercase(\"a b c\"))` is a bit backwards. If so, the piping operation `|>` is for you:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wRrmVEWG24_f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fd08d0f9-22ed-4b61-c591-01a6486eacb7"
      },
      "source": [
        "\"a b c\" |> uppercase |> split"
      ],
      "execution_count": 194,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3-element Vector{SubString{String}}:\n",
              " \"A\"\n",
              " \"B\"\n",
              " \"C\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 194
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c2Y1HRhG4S47"
      },
      "source": [
        "If you want to pass more than one argument to some of the functions, you can use anonymous functions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IzIFbaLQ4UCO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e6c9bcec-2f46-453c-d35b-ed5d08605168"
      },
      "source": [
        "\"a b c\" |> uppercase |> split |> tokens->join(tokens, \", \")"
      ],
      "execution_count": 195,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"A, B, C\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 195
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GcnKoRyHcGC6"
      },
      "source": [
        "The dotted version of the pipe operator works as you might expect, applying the _i_<sup>th</sup> function of the right array to the _i_<sup>th</sup> value in the left array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a7LytVDKbL_e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b864093-5971-4335-c06f-9f2a7fdf4a68"
      },
      "source": [
        "[π/2, \"hello\", 4] .|> [sin, length, x->x^2]"
      ],
      "execution_count": 196,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3-element Vector{Real}:\n",
              "  1.0\n",
              "  5\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 196
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Czk5ZFOn3LDi"
      },
      "source": [
        "## Composition\n",
        "Julia also lets you compose functions like mathematicians do, using the composition operator ∘ (`\\circ<tab>` in the REPL or Jupyter, but not Colab):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iK9UrlF2aU_y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9e43af12-8bb5-44ff-ebd6-8414af22a860"
      },
      "source": [
        "f = exp ∘ sin ∘ sqrt\n",
        "f(2.0) == exp(sin(sqrt(2.0)))"
      ],
      "execution_count": 197,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "true"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 197
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lQJKl9rD-BWj"
      },
      "source": [
        "# Methods\n",
        "Earlier, we discussed structs, which look a lot like Python classes, with instance variables and constructors, but they did not contain any methods (just the inner constructors). In Julia, methods are defined separately, like regular functions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "axvF_XwJ-DJw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "736942c1-e39d-481d-8cdb-fb5ae322fd86"
      },
      "source": [
        "struct Person\n",
        "    name\n",
        "    age\n",
        "end\n",
        "\n",
        "function greetings(greeter)\n",
        "    println(\"Hi, my name is $(greeter.name), I am $(greeter.age) years old.\")\n",
        "end\n",
        "\n",
        "p = Person(\"Alice\", 70)\n",
        "greetings(p)"
      ],
      "execution_count": 198,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi, my name is Alice, I am 70 years old.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ylOha2mhCRgz"
      },
      "source": [
        "Since the `greetings()` method in Julia is not bound to any particular type, we can use it with any other type we want, as long as that type has a `name` and an `age` (i.e., if it quacks like a duck):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vWkQqaEPCgeY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4201a797-503b-44c6-9afb-47037f4dd4fa"
      },
      "source": [
        "struct City\n",
        "    name\n",
        "    country\n",
        "    age\n",
        "end\n",
        "\n",
        "using Dates\n",
        "c = City(\"Auckland\", \"New Zealand\", year(now()) - 1840)\n",
        "\n",
        "greetings(c)"
      ],
      "execution_count": 199,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi, my name is Auckland, I am 181 years old.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sRI9XAbrLA0t"
      },
      "source": [
        "You could code this the same way in Python if you wanted to:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "class Person:\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "\n",
        "class City:\n",
        "    def __init__(self, name, country, age):\n",
        "        self.name = name\n",
        "        self.country = country\n",
        "        self.age = age\n",
        "\n",
        "def greetings(greeter):\n",
        "    print(f\"Hi there, my name is {greeter.name}, I am {greeter.age} years old.\")\n",
        "\n",
        "p = Person(\"Lucy\", 70)\n",
        "greetings(p)\n",
        " \n",
        "from datetime import date\n",
        "c = City(\"Auckland\", \"New Zealand\", date.today().year - 1840)\n",
        "greetings(c)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qIcoroYhG5_Y"
      },
      "source": [
        "However, many Python programmers would use inheritance in this case:\n",
        "\n",
        "```python\n",
        "class Greeter:\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "    def greetings(self):\n",
        "        print(f\"Hi there, my name is {self.name}, I am {self.age} years old.\")\n",
        "\n",
        "class Person(Greeter):\n",
        "    def __init__(self, name, age):\n",
        "        super().__init__(name, age)\n",
        "\n",
        "class City(Greeter):\n",
        "    def __init__(self, name, country, age):\n",
        "        super().__init__(name, age)\n",
        "        self.country = country\n",
        "\n",
        "p = Person(\"Lucy\", 70)\n",
        "p.greetings()\n",
        "\n",
        "from datetime import date\n",
        "c = City(\"Auckland\", \"New Zealand\", date.today().year - 1840)\n",
        "c.greetings()\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iRNLWOyURGGp"
      },
      "source": [
        "## Extending a Function\n",
        "One nice thing about having a class hierarchy is that you can override methods in subclasses to get specialized behavior for each class. For example, in Python you could override the `greetings()` method like this:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "class Developer(Person):\n",
        "    def __init__(self, name, age, language):\n",
        "        super().__init__(name, age)\n",
        "        self.language = language\n",
        "    def greetings(self):\n",
        "        print(f\"Hi there, my name is {self.name}, I am {self.age} years old.\")\n",
        "        print(f\"My favorite language is {self.language}.\")\n",
        "\n",
        "d = Developer(\"Amy\", 40, \"Julia\")\n",
        "d.greetings()\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "srgbdxLxSWGG"
      },
      "source": [
        "Notice that the expression `d.greetings()` will call a different method if `d` is a `Person` or a `Developer`. This is called \"polymorphism\": the same method call behaves differently depending on the type of the object. The language chooses which actual method implementation to call, based on the type of `d`: this is called method \"dispatch\". More specifically, since it only depends on a single variable, it is called \"single dispatch\".\n",
        "\n",
        "The good news is that Julia can do single dispatch as well:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j6fIldepUFA1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "385ea0b3-814f-48c3-a8cf-921917783929"
      },
      "source": [
        "struct Developer\n",
        "    name\n",
        "    age\n",
        "    language\n",
        "end\n",
        "\n",
        "function greetings(dev::Developer)\n",
        "    println(\"Hi, my name is $(dev.name), I am $(dev.age) years old.\")\n",
        "    println(\"My favorite language is $(dev.language).\")\n",
        "end\n",
        "\n",
        "d = Developer(\"Amy\", 40, \"Julia\")\n",
        "greetings(d)"
      ],
      "execution_count": 200,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi, my name is Amy, I am 40 years old.\n",
            "My favorite language is Julia.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ji22KZNVHub"
      },
      "source": [
        "Notice that the `dev` argument is followed by `::Developer`, which means that this method will only be called if the argument has that type.\n",
        "\n",
        "We have **extended** the `greetings` **function**, so that it now has two different implementations, called **methods**, each for different argument types: namely, `greetings(dev::Developer)` for arguments of type `Developer`, and `greetings(greeter)` for values of any other type.\n",
        "\n",
        "You can easily get the list of all the methods of a given function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6yQgjmjST2xL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 80
        },
        "outputId": "85daaf83-f177-4f12-a4f5-1d25cbcd1cdd"
      },
      "source": [
        "methods(greetings)"
      ],
      "execution_count": 201,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "# 2 methods for generic function <b>greetings</b>:<ul><li> greetings(dev::<b>Developer</b>) in Main at In[200]:7</li> <li> greetings(greeter) in Main at In[198]:6</li> </ul>"
            ],
            "text/plain": [
              "# 2 methods for generic function \"greetings\":\n",
              "[1] greetings(dev::Developer) in Main at In[200]:7\n",
              "[2] greetings(greeter) in Main at In[198]:6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 201
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iS7Byq8yd8uE"
      },
      "source": [
        "You can also get the list of all the methods which take a particular type as argument:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZxFaPzByd0qv",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 63
        },
        "outputId": "92ad9784-e0e2-4200-c4ab-d77a0949e2bf"
      },
      "source": [
        "methodswith(Developer)"
      ],
      "execution_count": 202,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "1-element Vector{Method}:<ul><li> greetings(dev::<b>Developer</b>) in Main at In[200]:7</ul>"
            ],
            "text/plain": [
              "[1] greetings(dev::Developer) in Main at In[200]:7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 202
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ab4DP1-fT7dE"
      },
      "source": [
        "When you call the `greetings()` function, Julia automatically dispatches the call to the appropriate method, depending on the type of the argument. If Julia can determine at compile time what the type of the argument will be, then it optimizes the compiled code so that there's no choice to be made at runtime. This is called **static dispatch**, and it can significantly speed up the program. If the argument's type can't be determined at compile time, then Julia makes the choice at runtime, just like in Python: this is called **dynamic dispatch**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y7U4rXr2GnFx"
      },
      "source": [
        "## Multiple Dispatch\n",
        "Julia actually looks at the types of _all_ the positional arguments, not just the first one. This is called **multiple dispatch**. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YE7pb7tHHEcb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b66e5431-3142-48c9-f7b2-b2ef39b49bf0"
      },
      "source": [
        "multdisp(a::Int64, b::Int64) = 1\n",
        "multdisp(a::Int64, b::Float64) = 2\n",
        "multdisp(a::Float64, b::Int64) = 3\n",
        "multdisp(a::Float64, b::Float64) = 4\n",
        "\n",
        "multdisp(10, 20) # try changing the arguments to get each possible output"
      ],
      "execution_count": 203,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 203
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wJtjHEYGJr5B"
      },
      "source": [
        "Julia always chooses the most specific method it can, so the following method will only be called if the first argument is neither an `Int64` nor a `Float64`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SrZv6JZBKZGF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e9e8ea6d-983a-4954-9738-28b810311f32"
      },
      "source": [
        "multdisp(a::Any, b::Int64) = 5\n",
        "\n",
        "multdisp(10, 20)"
      ],
      "execution_count": 204,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 204
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BiwKlUcMKvbr"
      },
      "source": [
        "Julia will raise an exception if there is some ambiguity as to which method is the most specific:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wnvxky-JJQxU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b88bd52d-9e42-4521-d3b2-c5c75990f5cf"
      },
      "source": [
        "ambig(a::Int64, b) = 1\n",
        "ambig(a, b::Int64) = 2\n",
        "\n",
        "try\n",
        "    ambig(10, 20)\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 205,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MethodError(ambig, (10, 20), 0x0000000000007413)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 205
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Pb7CA7kK8UT"
      },
      "source": [
        "To solve this problem, you can explicitely define a method for the ambiguous case:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mlr9q0GxLL-q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "143c7ddb-e56c-4d1e-f12d-473a5b9d2f52"
      },
      "source": [
        "ambig(a::Int64, b::Int64) = 3\n",
        "ambig(10, 20)"
      ],
      "execution_count": 206,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 206
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W19FsOf2GOcF"
      },
      "source": [
        "So you can have polymorphism in Julia, just like in Python. This means that you can write your algorithms in a generic way, without having to know the exact types of the values you are manipulating, and it will work fine, as long as these types act in the general way you expect (i.e., if they \"quack like ducks\"). For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L_i8ksenUoz8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b1e65a2f-2969-420b-883b-515c32be89e8"
      },
      "source": [
        "function how_can_i_help(greeter)\n",
        "    greetings(greeter)\n",
        "    println(\"How can I help?\")\n",
        "end\n",
        "\n",
        "how_can_i_help(p) # called on a Person\n",
        "how_can_i_help(d) # called on a Developer"
      ],
      "execution_count": 207,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi, my name is Alice, I am 70 years old.\n",
            "How can I help?\n",
            "Hi, my name is Amy, I am 40 years old.\n",
            "My favorite language is Julia.\n",
            "How can I help?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jZmax1CvVBKT"
      },
      "source": [
        "## Calling `super()`?\n",
        "You may have noticed that the `greetings(dev::Developer)` method could be improved, since it currently duplicates the implementation of the base method `greetings(greeter)`. In Python, you would get rid of this duplication by calling the base class's `greetings()` method, using `super()`:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "class Developer(Person):\n",
        "    def __init__(self, name, age, language):\n",
        "        super().__init__(name, age)\n",
        "        self.language = language\n",
        "    def greetings(self):\n",
        "        super().greetings() # <== THIS!\n",
        "        print(f\"My favorite language is {self.language}.\")\n",
        "\n",
        "d = Developer(\"Amy\", 40, \"Julia\")\n",
        "d.greetings()\n",
        "```\n",
        "\n",
        "In Julia, you can do something pretty similar, although you have to implement your own `super()` function, as it is not part of the language:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Oz-Xe4VmMRr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a0c66bb-3e21-45f5-e904-51c883d9958f"
      },
      "source": [
        "super(dev::Developer) = Person(dev.name, dev.age)\n",
        "\n",
        "function greetings(dev::Developer)\n",
        "    greetings(super(dev))\n",
        "    println(\"My favorite language is $(dev.language).\")\n",
        "end\n",
        "\n",
        "greetings(d)"
      ],
      "execution_count": 208,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi, my name is Amy, I am 40 years old.\n",
            "My favorite language is Julia.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WqtmgScLr3oz"
      },
      "source": [
        "However, this implementation creates a new `Person` instance when calling `super(dev)`, copying the `name` and `age` fields. That's okay for small objects, but it's not ideal for larger ones. Instead, you can explicitely call the specific method you want by using the `invoke()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XPlSZ5kaqz0l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "039dfa0c-fcb4-4b1a-85f3-7ce9149ad130"
      },
      "source": [
        "function greetings(dev::Developer)\n",
        "    invoke(greetings, Tuple{Any}, dev)\n",
        "    println(\"My favorite language is $(dev.language).\")\n",
        "end\n",
        "\n",
        "greetings(d)"
      ],
      "execution_count": 209,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi, my name is Amy, I am 40 years old.\n",
            "My favorite language is Julia.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vrf7C_Cgsob2"
      },
      "source": [
        "The `invoke()` function expects the following arguments:\n",
        "* The first argument is the function to call.\n",
        "* The second argument is the type of the desired method's arguments tuple: `Tuple{TypeArg1, TypeArg2, etc.}`. In this case we want to call the base function, which takes a single `Any` argument (the `Any` type is implicit when no type is specified).\n",
        "* Lastly, it takes all the arguments to be passed to the method. In this case, there's just one: `dev`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "emqToYz-ypOS"
      },
      "source": [
        "As you can see, we managed to get the same advantages Object-Oriented programming offers, without defining classes or using inheritance. This takes a bit of getting used to, but you might come to prefer this style of generic programming. Indeed, OO programming encourage you to bundle data and behavior together, but this is not always a good idea. Let's look at one example:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "class Rectangle:\n",
        "    def __init__(self, height, width):\n",
        "        self.height = height\n",
        "        self.width = width\n",
        "    def area(self):\n",
        "        return self.height * self.width\n",
        "\n",
        "class Square(Rectangle):\n",
        "    def __init__(self, length):\n",
        "        super().__init__(length, length)\n",
        "```\n",
        "\n",
        "It makes sense for the `Square` class to be a subclass of the `Rectangle` class, since a square **is a** special type of rectangle. It also makes sense for the `Square` class to inherit from all of the `Rectangle` class's behavior, such as the `area()` method. However, it does not really make sense for rectangles and squares to have the same memory representation: a `Rectangle` needs two numbers (`height` and `width`), while a `Square` only needs one (`length`).\n",
        "\n",
        "It's possible to work around this issue like this:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "class Rectangle:\n",
        "    def __init__(self, height, width):\n",
        "        self.height = height\n",
        "        self.width = width\n",
        "    def area(self):\n",
        "        return self.height * self.width\n",
        "\n",
        "class Square(Rectangle):\n",
        "    def __init__(self, length):\n",
        "        self.length = length\n",
        "    @property\n",
        "    def width(self):\n",
        "        return self.length\n",
        "    @property\n",
        "    def height(self):\n",
        "        return self.length\n",
        "```\n",
        "\n",
        "That's better: now, each square is only represented using a single number. We've inherited the behavior, but not the data.\n",
        "\n",
        "In Julia, you could code this like so:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G7aHm-s_y92c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6bab0e4f-40a1-4213-f775-ebe51817a8b1"
      },
      "source": [
        "struct Rectangle\n",
        "    width\n",
        "    height\n",
        "end\n",
        "\n",
        "width(rect::Rectangle) = rect.width\n",
        "height(rect::Rectangle) = rect.height\n",
        "\n",
        "area(rect) = width(rect) * height(rect)\n",
        "\n",
        "struct Square\n",
        "    length\n",
        "end\n",
        "\n",
        "width(sq::Square) = sq.length\n",
        "height(sq::Square) = sq.length"
      ],
      "execution_count": 210,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "height (generic function with 2 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 210
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1Ck-ML8CuOMm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c9a2082-0ce3-48ed-c877-8f7e319e9c42"
      },
      "source": [
        "area(Square(5))"
      ],
      "execution_count": 211,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "25"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 211
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUy8eU__-swA"
      },
      "source": [
        "Notice that the `area()` function relies on the getters `width()` and `height()`, rather than directly on the fields `width` and `height`. This way, the argument can be of any type at all, as long as it has these getters."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iPtX04AJkXnI"
      },
      "source": [
        "## Abstract Types\n",
        "One nice thing about the class hierarchy we defined in Python is that it makes it clear that a square **is a** kind of rectangle. Any new function you define that takes a `Rectangle` as an argument will automatically accept a `Square` as well, but no other non-rectangle type. In contrast, our `area()` function currently accepts anything at all.\n",
        "\n",
        "In Julia, a concrete type like `Square` cannot extend another concrete type like `Rectangle`. However, any type can extend from an abstract type. Let's define some abstract types to create a type hierarchy for our `Square` and `Rectangle` types."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HgXYu8Y7kFf7"
      },
      "source": [
        "abstract type AbstractShape end\n",
        "abstract type AbstractRectangle <: AbstractShape end  # <: means \"subtype of\"\n",
        "abstract type AbstractSquare <: AbstractRectangle end"
      ],
      "execution_count": 212,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s9jYhVkntUXo"
      },
      "source": [
        "The `<:` operator means \"subtype of\"."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SFoq_2FUtjix"
      },
      "source": [
        "Now we can attach the `area()` function to the `AbstractRectangle` type, instead of any type at all:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DpCEaRNytYNQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "55499622-40c6-4d1b-923c-bc48196350b3"
      },
      "source": [
        "area(rect::AbstractRectangle) = width(rect) * height(rect)"
      ],
      "execution_count": 213,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "area (generic function with 2 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 213
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "utwPa8jLt7bF"
      },
      "source": [
        "Now we can define the concrete types, as subtypes of `AbstractRectangle` and `AbstractSquare`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cHChkf1Mt0GN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "145d716f-a3e5-4ef8-89ff-17e985515fed"
      },
      "source": [
        "struct Rectangle_v2 <: AbstractRectangle\n",
        "  width\n",
        "  height\n",
        "end\n",
        "\n",
        "width(rect::Rectangle_v2) = rect.width\n",
        "height(rect::Rectangle_v2) = rect.height\n",
        "\n",
        "struct Square_v2 <: AbstractSquare\n",
        "  length\n",
        "end\n",
        "\n",
        "width(sq::Square_v2) = sq.length\n",
        "height(sq::Square_v2) = sq.length"
      ],
      "execution_count": 214,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "height (generic function with 4 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 214
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N6JklHCruNkP"
      },
      "source": [
        "In short, the Julian approach to type hierarchies looks like this:\n",
        "\n",
        "* Create a hierarchy of abstract types to represent the concepts you want to implement.\n",
        "* Write functions for these abstract types. Much of your implementation can be coded at that level, manipulating abstract concepts.\n",
        "* Lastly, create concrete types, and write the methods needed to give them the behavior that is expected by the generic algorithms you wrote."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GZA6mB9hu3pg"
      },
      "source": [
        "This pattern is used everywhere in Julia's standard libraries. For example, here are the supertypes of `Float64` and `Int64`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "No9X1dLtu-nj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89a4b9a2-211e-4a71-d1a8-6d3f7995481c"
      },
      "source": [
        "Base.show_supertypes(Float64)"
      ],
      "execution_count": 215,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Float64 <: AbstractFloat <: Real <: Number <: Any"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RowhPCR_R-QG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c9c78a4-1968-4453-c50f-6631cc3e6ff2"
      },
      "source": [
        "Base.show_supertypes(Int64)"
      ],
      "execution_count": 216,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Int64 <: Signed <: Integer <: Real <: Number <: Any"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fTFddfq0CEyy"
      },
      "source": [
        "Note: Julia implicitly runs `using Core` and `using Base` when starting the REPL. However, the `show_supertypes()` function is not exported by the `Base` module, thus you cannot access it by just typing `show_supertypes(Float64)`. Instead, you have to specify the module name: `Base.show_supertypes(Float64)`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K-q4QCgI-rWI"
      },
      "source": [
        "And here is the whole hierarchy of `Number` types:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Gtn6IB0vQZv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "00882e83-7777-4116-87a3-64c7de5e3c5b"
      },
      "source": [
        "function show_hierarchy(root, indent=0)\n",
        "    println(repeat(\" \", indent * 4), root)\n",
        "    for subtype in subtypes(root)\n",
        "        show_hierarchy(subtype, indent + 1)\n",
        "    end\n",
        "end\n",
        "\n",
        "show_hierarchy(Number)"
      ],
      "execution_count": 217,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number\n",
            "    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",
            "            Signed\n",
            "                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"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NdE0eLaKf_tM"
      },
      "source": [
        "## Iterator Interface\n",
        "You will sometimes want to provide a way to iterate over your custom types. In Python, this requires defining the `__iter__()` method which should return an object which implements the `__next__()` method. In Julia, you must define at least two functions:\n",
        "* `iterate(::YourIteratorType)`, which must return either `nothing` if there are no values in the sequence, or `(first_value, iterator_state)`.\n",
        "* `iterate(::YourIteratorType, state)`, which must return either `nothing` if there are no more values, or `(next_value, new_iterator_state)`.\n",
        "\n",
        "For example, let's create a simple iterator for the Fibonacci sequence:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "baemCHqZde4Y"
      },
      "source": [
        "struct FibonacciIterator end"
      ],
      "execution_count": 218,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yidgsJt9eBSk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fc6e365d-ba01-4ee1-f34d-82ef6bf56a06"
      },
      "source": [
        "import Base.iterate\n",
        "\n",
        "iterate(f::FibonacciIterator) = (1, (1, 1))\n",
        "\n",
        "function iterate(f::FibonacciIterator, state)\n",
        "    new_state = (state[2], state[1] + state[2])\n",
        "    (new_state[1], new_state)\n",
        "end"
      ],
      "execution_count": 219,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "iterate (generic function with 238 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 219
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9CORRxR8hYrl"
      },
      "source": [
        "Now we can iterate over a `FibonacciIterator` instance:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5W0QbY41fJGE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb768a89-35ec-400a-e4d0-f4a8565139db"
      },
      "source": [
        "for f in FibonacciIterator()\n",
        "    println(f)\n",
        "    f > 10 && break\n",
        "end"
      ],
      "execution_count": 220,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RjEk9nRIhmwV"
      },
      "source": [
        "## Indexing Interface\n",
        "You can also create a type that will be indexable like an array (allowing syntax like `a[5] = 3`). In Python, this requires implementing the `__getitem__()` and `__setitem__()` methods. In Julia, you must implement the `getindex(A::YourType, i)`, `setindex!(A::YourType, v, i)`, `firstindex(A::YourType)` and `lastindex(A::YourType)` methods."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i-r1StLujBEL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82a8f18d-f48f-41cc-d62d-83903180bbdf"
      },
      "source": [
        "struct MySquares end\n",
        "\n",
        "import Base.getindex, Base.firstindex\n",
        "\n",
        "getindex(::MySquares, i) = i^2\n",
        "firstindex(::MySquares) = 0\n",
        "\n",
        "S = MySquares()\n",
        "S[10]"
      ],
      "execution_count": 221,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "100"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 221
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p8zfJLvDjpSP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2d72068d-9c2a-4229-e679-c2fb92bc9023"
      },
      "source": [
        "S[begin]"
      ],
      "execution_count": 222,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 222
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n9y4Y2r2jzTG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c134323e-68a0-47f6-d9ac-b3985457e906"
      },
      "source": [
        "getindex(S::MySquares, r::UnitRange) = [S[i] for i in r]"
      ],
      "execution_count": 223,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "getindex (generic function with 237 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 223
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vk-gqI08jrQo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dcbb33ea-dab6-4af8-bfa4-59780a982c5c"
      },
      "source": [
        "S[1:4]"
      ],
      "execution_count": 224,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              "  1\n",
              "  4\n",
              "  9\n",
              " 16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 224
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1j3qxO4TkoVm"
      },
      "source": [
        "For more details on these interfaces, and to learn how to build full-blown array types with broadcasting and more, check out [this page](https://docs.julialang.org/en/v1/manual/interfaces/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bD9gzH2XDlGL"
      },
      "source": [
        "## Creating a Number Type\n",
        "Let's create a `MyRational` struct and try to make it mimic the built-in `Rational` type:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nwEtMyR1PB3C"
      },
      "source": [
        "struct MyRational <: Real\n",
        "    num # numerator\n",
        "    den # denominator\n",
        "end"
      ],
      "execution_count": 225,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cwCpLCW6PePs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f04cdad-df4b-4930-c0ac-a71841f98091"
      },
      "source": [
        "MyRational(2, 3)"
      ],
      "execution_count": 226,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MyRational(2, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 226
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vbIz77VzST24"
      },
      "source": [
        "It would be more convenient and readable if we could type `2 ⨸ 3` to create a `MyRational`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VuitXq8eTL4G",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eaf5ed34-6e75-4584-f899-7ccce939fb5a"
      },
      "source": [
        "function ⨸(num, den)\n",
        "    MyRational(num, den)\n",
        "end"
      ],
      "execution_count": 227,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "⨸ (generic function with 1 method)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 227
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "isQcJMAeTRi-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "76dde7d2-dc50-4076-949c-0f708095990d"
      },
      "source": [
        "2 ⨸ 3"
      ],
      "execution_count": 228,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MyRational(2, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 228
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g594gvCpTTYB"
      },
      "source": [
        "I chose `⨸` because it's a symbol that Julia's parser treats as a binary operator, but which is otherwise not used by Julia (see the full [list of parsed symbols](https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm) and their priorities). This particular symbol will have the same priority as multiplication and division."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3DKaUnqsUG0L"
      },
      "source": [
        "If you want to know how to type it and check that it is unused, type `?⨸` (copy/paste the symbol):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "km3KccbsUTnQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "af410061-0cc1-4838-b67f-c58db99e11c0"
      },
      "source": [
        "?⨸"
      ],
      "execution_count": 229,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\"\u001b[36m⨸\u001b[39m\" can be typed by \u001b[36m\\odiv<tab>\u001b[39m\n",
            "\n",
            "search: \u001b[0m\u001b[1m⨸\u001b[22m\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/latex": "No documentation found.\n\n\\texttt{⨸} is a \\texttt{Function}.\n\n\\begin{verbatim}\n# 1 method for generic function \"⨸\":\n[1] ⨸(num, den) in Main at In[227]:1\n\\end{verbatim}\n",
            "text/markdown": "No documentation found.\n\n`⨸` is a `Function`.\n\n```\n# 1 method for generic function \"⨸\":\n[1] ⨸(num, den) in Main at In[227]:1\n```\n",
            "text/plain": [
              "  No documentation found.\n",
              "\n",
              "  \u001b[36m⨸\u001b[39m is a \u001b[36mFunction\u001b[39m.\n",
              "\n",
              "\u001b[36m  # 1 method for generic function \"⨸\":\u001b[39m\n",
              "\u001b[36m  [1] ⨸(num, den) in Main at In[227]:1\u001b[39m"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 229
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eWzNstBqQckD"
      },
      "source": [
        "Now let's make it possible to add two `MyRational` values. We want it to be possible for our `MyRational` type to be used in existing algorithms which rely on `+`, so we must create a new method for the `Base.+` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2T7MyjE2RhUW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c9b90689-7f9b-486d-ab6f-0eb9bb66fa0d"
      },
      "source": [
        "import Base.+\n",
        "\n",
        "function +(r1::MyRational, r2::MyRational)\n",
        "    (r1.num * r2.den + r1.den * r2.num) ⨸ (r1.den * r2.den)\n",
        "end"
      ],
      "execution_count": 230,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "+ (generic function with 197 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 230
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aFtoPHZRSNoU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9302ae74-f8f9-4a28-b2d7-243e958eab9b"
      },
      "source": [
        "2 ⨸ 3 + 3 ⨸ 5"
      ],
      "execution_count": 231,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MyRational(19, 15)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 231
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8--bQ8izR7_I"
      },
      "source": [
        "It's important to import `Base.+` first, or else you would just be defining a new `+` function in the current module (`Main`), which would not be called by existing algorithms."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x79nFEHQYFfU"
      },
      "source": [
        "You can easily implement `*`, `^` and so on, in much the same way."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GGTgc07sSR4w"
      },
      "source": [
        "Let's change the way `MyRational` values are printed, to make them look a bit nicer. For this, we must create a new method for the `Base.show(io::IO, x)` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KQN5IqLxVzLF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b71e4fc-33d2-4dd6-fedd-2cde0bcc84f1"
      },
      "source": [
        "import Base.show\n",
        "\n",
        "function show(io::IO, r::MyRational)\n",
        "    print(io, \"$(r.num) ⨸ $(r.den)\")\n",
        "end\n",
        "\n",
        "2 ⨸ 3 + 3 ⨸ 5"
      ],
      "execution_count": 232,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "19 ⨸ 15"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 232
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rJg_-ZYOXS4m"
      },
      "source": [
        "We can expand the `show()` function so it can provide an HTML representation for `MyRational` values. This will be called by the `display()` function in Jupyter or Colab:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h6smoUzBWkNB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 40
        },
        "outputId": "85fb81f2-d561-4ed4-d8d3-66d6af1b9b5a"
      },
      "source": [
        "function show(io::IO, ::MIME\"text/html\", r::MyRational)\n",
        "    print(io, \"<sup><b>$(r.num)</b></sup>&frasl;<sub><b>$(r.den)</b></sub>\")\n",
        "end\n",
        "\n",
        "2 ⨸ 3 + 3 ⨸ 5"
      ],
      "execution_count": 233,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<sup><b>19</b></sup>&frasl;<sub><b>15</b></sub>"
            ],
            "text/plain": [
              "19 ⨸ 15"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 233
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5bOKggSjX7hM"
      },
      "source": [
        "Next, we want to be able to perform any operation involving `MyRational` values and values of other `Number` types. For example, we may want to multiply integers and `MyRational` values. One option is to define a new method like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dlW_pbUPZL_0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 40
        },
        "outputId": "67c4348e-4e15-4dee-91d5-4c90496d97fe"
      },
      "source": [
        "import Base.*\n",
        "\n",
        "function *(r::MyRational, i::Integer)\n",
        "    (r.num * i) ⨸ r.den\n",
        "end\n",
        "\n",
        "2 ⨸ 3 * 5"
      ],
      "execution_count": 234,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<sup><b>10</b></sup>&frasl;<sub><b>3</b></sub>"
            ],
            "text/plain": [
              "10 ⨸ 3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 234
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Xr--hB-ZlDm"
      },
      "source": [
        "Since multiplication is commutative, we need the reverse method as well:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3DkeVGqaZtNv",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 40
        },
        "outputId": "836ad7ae-f9ac-43fb-c772-418ebebbe3df"
      },
      "source": [
        "function *(i::Integer, r::MyRational)\n",
        "    r * i # this will call the previous method\n",
        "end\n",
        "\n",
        "5 * (2 ⨸ 3) # we need the parentheses since * and ⨸ have the same priority"
      ],
      "execution_count": 235,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<sup><b>10</b></sup>&frasl;<sub><b>3</b></sub>"
            ],
            "text/plain": [
              "10 ⨸ 3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 235
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hzW07JkXggLo"
      },
      "source": [
        "It's cumbersome to have to define these methods for every operation. There's a better way, which we will explore in the next two sections."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TWXZrND8N-nR"
      },
      "source": [
        "## Conversion\n",
        "It is possible to provide a way for integers to be automatically converted to `MyRational` values:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SFIenX2Og0qY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 40
        },
        "outputId": "0cb46e3f-8f9e-43d9-ec88-76328f14b4a9"
      },
      "source": [
        "import Base.convert\n",
        "\n",
        "MyRational(x::Integer) = MyRational(x, 1)\n",
        "\n",
        "convert(::Type{MyRational}, x::Integer) = MyRational(x)\n",
        "\n",
        "convert(MyRational, 42)"
      ],
      "execution_count": 236,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<sup><b>42</b></sup>&frasl;<sub><b>1</b></sub>"
            ],
            "text/plain": [
              "42 ⨸ 1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 236
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n_gGRgRSwrkS"
      },
      "source": [
        "The `Type{MyRational}` type is a special type which has a single instance: the `MyRational` type itself. So this `convert()` method only accepts `MyRational` itself as its first argument (and we don't actually use the first argument, so we don't even need to give it a name in the function declaration)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5B9cNbV5lbHm"
      },
      "source": [
        "Now integers will be automatically converted to `MyRational` values when you assign them to an array whose element type if `MyRational`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YWdijh_2k7LU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ede651b0-e069-40e3-d7b8-5d31bca7bd6c"
      },
      "source": [
        "a = [2 ⨸ 3] # the element type is MyRational\n",
        "a[1] = 5    # convert(MyRational, 5) is called automatically\n",
        "push!(a, 6) # convert(MyRational, 6) is called automatically\n",
        "println(a)"
      ],
      "execution_count": 237,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "MyRational[5 ⨸ 1, 6 ⨸ 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ESWblH5olvOY"
      },
      "source": [
        "Conversion will also occur automatically in these cases:\n",
        "* `r::MyRational = 42`: assigning an integer to `r` where `r` is a local variable with a declared type of `MyRational`.\n",
        "* `s.b = 42` if `s` is a struct and `b` is a field of type `MyRational` (also when calling `new(42)` on that struct, assuming `b` is the first field).\n",
        "* `return 42` if the return type is declared as `MyRational` (e.g., `function f(x)::MyRational ... end`)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kIulkBomd5hy"
      },
      "source": [
        "However, there is no automatic conversion when calling functions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7Jf6rT8uhAtU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ce3c2c7-e82d-4a8f-e099-1bc4de4c51e3"
      },
      "source": [
        "function for_my_rationals_only(x::MyRational)\n",
        "    println(\"It works:\", x)\n",
        "end\n",
        "\n",
        "try\n",
        "    for_my_rationals_only(42)\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 238,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MethodError(for_my_rationals_only, (42,), 0x000000000000743a)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 238
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KhtxelSROzU_"
      },
      "source": [
        "## Promotion\n",
        "The `Base` functions `+`, `-`, `*`, `/`, `^`, etc. all use a \"promotion\" algorithm to convert the arguments to the appropriate type. For example, adding an integer and a float promotes the integer to a float before the addition takes place. These functions use the `promote()` function for this. For example, given several integers and a float, all integers get promoted to floats:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BEa8TRPuokYN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c31d2436-24a0-4466-a48f-a12bfc25a43b"
      },
      "source": [
        "promote(1, 2, 3, 4.0)"
      ],
      "execution_count": 239,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1.0, 2.0, 3.0, 4.0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 239
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wDpLvwpMPP59"
      },
      "source": [
        "This is why a sum of integers and floats results in a float:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "grWU-hHHPI7v",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bb0d7f01-e47d-4041-ab36-abb0b4d79d98"
      },
      "source": [
        "1 + 2 + 3 + 4.0"
      ],
      "execution_count": 240,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 240
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pkrDanbRO7b2"
      },
      "source": [
        "The `promote()` function is also called when creating an array. For example, the following array is a `Float64` array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AeDsWTZjO-4d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39c60049-4a41-4956-a665-b0eea56837ea"
      },
      "source": [
        "a = [1, 2, 3, 4.0]"
      ],
      "execution_count": 241,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Float64}:\n",
              " 1.0\n",
              " 2.0\n",
              " 3.0\n",
              " 4.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 241
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JCdZ4NhMo505"
      },
      "source": [
        "What about the `MyRational` type? Rather than create new methods for the `promote()` function, the recommended approach is to create a new method for the `promote_rule()` function. It takes two types and returns the type to convert to:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3xJTjr7XPgtx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cfd433e7-e659-4970-978b-d0bc37acf0b5"
      },
      "source": [
        "promote_rule(Float64, Int64)"
      ],
      "execution_count": 242,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 242
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W68U2_SjPt_T"
      },
      "source": [
        "Let's implement a new method for this function, to make sure that any subtype of the `Integer` type will be promoted to `MyRational`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wjK9_3Bierna",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "75193898-3476-42a3-9e9b-d4daf76d89a3"
      },
      "source": [
        "import Base.promote_rule\n",
        "\n",
        "promote_rule(::Type{MyRational}, ::Type{T}) where {T <: Integer} = MyRational"
      ],
      "execution_count": 243,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "promote_rule (generic function with 143 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 243
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OSXo1GaxwU9F"
      },
      "source": [
        "This method definition uses **parametric types**: the type `T` can be any type at all, as long as it is a subtype of the `Integer` abstract type. If you tried to define the method `promote_rule(::Type{MyRational}, ::Type{Integer})`, it would expect the type `Integer` itself as the second argument, which would not work, since the `promote_rule()` function will usually be called with concrete types like `Int64` as its arguments."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cn7m2aTTrC6X"
      },
      "source": [
        "Let's check that it works:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bD7p0DHFfaCg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0575ffc0-3636-4cfd-fdb1-ce5afe82e184"
      },
      "source": [
        "promote(5, 2 ⨸ 3)"
      ],
      "execution_count": 244,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5 ⨸ 1, 2 ⨸ 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 244
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WVRYV79ErH81"
      },
      "source": [
        "Yep! Now whenever we call `+`, `-`, etc., with an integer and a `MyRational` value, the integer will get automatically promoted to a `MyRational` value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lmjjo9lSegy9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 40
        },
        "outputId": "c2cb48dc-bddf-41cd-88c9-d84affef2003"
      },
      "source": [
        "5 + 2 ⨸ 3"
      ],
      "execution_count": 245,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<sup><b>17</b></sup>&frasl;<sub><b>3</b></sub>"
            ],
            "text/plain": [
              "17 ⨸ 3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 245
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B6jVZiYXxuPJ"
      },
      "source": [
        "Under the hood:\n",
        "* this called `+(5, 2 ⨸ 3)`,\n",
        "  * which called the `+(::Number, ::Number)` method (thanks to multiple dispatch),\n",
        "    * which called `promote(5, 2 ⨸ 3)`,\n",
        "      * which called `promote_rule(Int64, MyRational)`,\n",
        "        * which called `promote_rule(::MyRational, ::T) where {T <: Integer}`,\n",
        "          * which returned `MyRational`,\n",
        "    * then the `+(::Number, ::Number)` method called `convert(MyRational, 5)`,\n",
        "      * which called `MyRational(5)`,\n",
        "        * which returned `MyRational(5, 1)`,\n",
        "    * and finally `+(::Number, ::Number)` called `+(MyRational(5, 1), MyRational(2, 3))`,\n",
        "      * which returned `MyRational(17, 3)`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d30Q7aANrik5"
      },
      "source": [
        "The benefit of this approach is that we only need to implement the `+`, `-`, etc. functions for pairs of `MyRational` values, not with all combinations of `MyRational` values and integers."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GftnTFTyLchM"
      },
      "source": [
        "If your head hurts, it's perfectly normal. ;-) Writing a new type that is easy to use, flexible and plays nicely with existing types takes a bit of planning and work, but the point is that you will not write these every day, and once you have, they will make your life much easier."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GSVv5YNisaxJ"
      },
      "source": [
        "Now let's handle the case where we want to execute operations with `MyRational` values and floats. In this case, we naturally want to promote the `MyRational` value to a float. We first need to define how to convert a `MyRational` value to any subtype of `AbstractFloat`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DZSFfORzrx4I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f8835e2e-c4bb-4a38-d398-91b48c512643"
      },
      "source": [
        "convert(::Type{T}, x::MyRational) where {T <: AbstractFloat} = T(x.num / x.den)"
      ],
      "execution_count": 246,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "convert (generic function with 250 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 246
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XC5z7YxcMjJN"
      },
      "source": [
        "This `convert()` works with any type `T` which is a subtype of `AbstractFloat`. It just computes `x.num / x.den` and converts the result to type `T`. Let's try it:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LxPjD04VMBXg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "88528f08-cb77-403b-9a31-6dec6bca2cbf"
      },
      "source": [
        "convert(Float64, 3 ⨸ 2)"
      ],
      "execution_count": 247,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 247
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Iity08_TMyLa"
      },
      "source": [
        "Now let's define a `promote_rule()` method which will work for any type `T` which is a subtype of `AbstractFloat`, and which will give priority to `T` over `MyRational`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S2xlgBf8MGa8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "61c6daac-7223-480c-dc4a-1521b6515920"
      },
      "source": [
        "promote_rule(::Type{MyRational}, ::Type{T}) where {T <: AbstractFloat} = T"
      ],
      "execution_count": 248,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "promote_rule (generic function with 144 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 248
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Xe9_k_GQZw0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "95612c4a-6ef5-4c38-e3d2-6c802a59e80f"
      },
      "source": [
        "promote(1 ⨸ 2, 4.0)"
      ],
      "execution_count": 249,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.5, 4.0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 249
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZRQrziIuNONH"
      },
      "source": [
        "Now we can combine floats and `MyRational` values easily:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ncZJSLjTsMsG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6d1ee26a-caed-476e-b3d7-15f2151d1cca"
      },
      "source": [
        "2.25 ^ (1 ⨸ 2)"
      ],
      "execution_count": 250,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 250
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p6msWOnrRwTO"
      },
      "source": [
        "## Parametric Types and Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6aNBefNARChe"
      },
      "source": [
        "Julia's `Rational` type is actually a **parametric type** which ensures that the numerator and denominator have the same type `T`, subtype of `Integer`. Here's a new version of our rational struct which enforces the same constraint:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I0Vyf_ogRdy0"
      },
      "source": [
        "struct MyRational2{T <: Integer}\n",
        "    num::T\n",
        "    den::T\n",
        "end"
      ],
      "execution_count": 251,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SHdhiFdlSwOd"
      },
      "source": [
        "To instantiate this type, we can specify the type `T`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FTfSXjQ4RseZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "533ab010-70c2-4eff-fc67-209b19b3ce33"
      },
      "source": [
        "MyRational2{BigInt}(2, 3)"
      ],
      "execution_count": 252,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MyRational2{BigInt}(2, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 252
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_dFuAINiTboo"
      },
      "source": [
        "Alternatively, we can use the `MyRational2` type's default constructor, with two integers of the same type:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Q8RWIB8Toq7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "91d9b1fe-70bf-4bc9-95e2-96f056dc6b47"
      },
      "source": [
        "MyRational2(2, 3)"
      ],
      "execution_count": 253,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MyRational2{Int64}(2, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 253
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8hhYRFcWXKkG"
      },
      "source": [
        "If we want to be able to construct a `MyRational2` with integers of different types, we must write an appropriate constructor which handles the promotion rule:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BdRaOp44XS-I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "957a947b-5c8c-45b7-b2b2-dd61951ad364"
      },
      "source": [
        "function MyRational2(num::Integer, den::Integer)\n",
        "    MyRational2(promote(num, den)...)\n",
        "end"
      ],
      "execution_count": 254,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MyRational2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 254
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F1-HWooSXwRj"
      },
      "source": [
        "This constructor accepts two integers of potentially different types, and promotes them to the same type. Then it calls the default `MyRational2` constructor which expects two arguments of the same type. The syntax `f(args...)` is analog to Python's `f(*args)`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ui3Oe7CHYhKs"
      },
      "source": [
        "Let's see if this works:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "55PS-B4kXsMv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3963a04a-7f1f-4283-cada-f19b8598ff88"
      },
      "source": [
        "MyRational2(2, BigInt(3))"
      ],
      "execution_count": 255,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MyRational2{BigInt}(2, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 255
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FYBh3sMgXvIy"
      },
      "source": [
        "Great!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TFB6iS8cYuwk"
      },
      "source": [
        "Note that all parametrized types such as `MyRational2{Int64}` or `MyRational2{BigInt}` are subtypes of `MyRational2`. So if a function accepts a `MyRational2` argument, you can pass it an instance of any specific, parametrized type:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xoe56vbfZXr8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8201fd63-6a56-4004-ac65-108e73f4691c"
      },
      "source": [
        "function for_any_my_rational2(x::MyRational2)\n",
        "    println(x)\n",
        "end\n",
        "\n",
        "for_any_my_rational2(MyRational2{BigInt}(1, 2))\n",
        "for_any_my_rational2(MyRational2{Int64}(1, 2))"
      ],
      "execution_count": 256,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "MyRational2{BigInt}(1, 2)\n",
            "MyRational2{Int64}(1, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KK02R7mAazjo"
      },
      "source": [
        "A more explicit (but verbose) syntax for this function is:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w9wLF0uYa377",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3d7db03d-ee3d-4212-e899-e7f7231af3b0"
      },
      "source": [
        "function for_any_my_rational2(x::MyRational2{T}) where {T <: Integer}\n",
        "    println(x)\n",
        "end"
      ],
      "execution_count": 257,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "for_any_my_rational2 (generic function with 1 method)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 257
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HzrkuhIMT3rq"
      },
      "source": [
        "It's useful to think of types as sets. For example, the `Int64` type represents the set of all 64-bit integer values, so `42 isa Int64`:\n",
        "* When `x` is an instance of some type `T`, it is an element of the set `T` represents, and `x isa T`.\n",
        "* When `U` is a subtype of `V`, `U` is a subset of `V`, and `U <: V`.\n",
        "\n",
        "The `MyRational2` type itself (without any parameter) represents the set of all values of `MyRational2{T}` for all subtypes `T` of `Integer`. In other words, it is the union of all the `MyRational2{T}` types. This is called a `UnionAll` type, and indeed the type `MyRational2` itself is an instance of the `UnionAll` type:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hGKucwR4Z78q"
      },
      "source": [
        "@assert MyRational2{BigInt}(2, 3) isa MyRational2{BigInt}\n",
        "@assert MyRational2{BigInt}(2, 3) isa MyRational2\n",
        "@assert MyRational2 === (MyRational2{T} where {T <: Integer})\n",
        "@assert MyRational2{BigInt} <: MyRational2\n",
        "@assert MyRational2 isa UnionAll"
      ],
      "execution_count": 258,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tv483WelU4It"
      },
      "source": [
        "If we dump the `MyRational2` type, we can see that it is a `UnionAll` instance, with a parameter type `T`, constrained to a subtype of the `Integer` type (since the upper bound `ub` is `Integer`):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Xzox_pwU1AA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fc00891a-1112-49a3-b1b9-749c65243a9a"
      },
      "source": [
        "dump(MyRational2)"
      ],
      "execution_count": 259,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "UnionAll\n",
            "  var: TypeVar\n",
            "    name: Symbol T\n",
            "    lb: Union{}\n",
            "    ub: Integer <: Real\n",
            "  body: MyRational2{T<:Integer} <: Any\n",
            "    num::T\n",
            "    den::T\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eEpPNFJBcoag"
      },
      "source": [
        "There's a lot more to learn about Julia types. When you feel ready to explore this in more depth, check out [this page](https://docs.julialang.org/en/v1.4/manual/types/). You can also take a look at the [source code of Julia's rationals](https://github.com/JuliaLang/julia/blob/master/base/rational.jl)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KmT7ZJEMJ2Vv"
      },
      "source": [
        "# Writing/Reading Files\n",
        "The `do` syntax we saw earlier is helpful when using the `open()` function:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oGW3LMvkJ6JM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5fe2cfd4-6454-4ce6-85df-d4dadb4a19f5"
      },
      "source": [
        "open(\"test.txt\", \"w\") do f\n",
        "    write(f, \"This is a test.\\n\")\n",
        "    write(f, \"I repeat, this is a test.\\n\")\n",
        "end\n",
        "\n",
        "open(\"test.txt\") do f\n",
        "    for line in eachline(f)\n",
        "        println(\"[$line]\")\n",
        "    end\n",
        "end"
      ],
      "execution_count": 260,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[This is a test.]\n",
            "[I repeat, this is a test.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f6XIenvgKdzR"
      },
      "source": [
        "The `open()` function automatically closes the file at the end of the block. Notice that the line feeds `\\n` at the end of each line are not returned by the `eachline()` function. So the equivalent Python code is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "with open(\"test.txt\", \"w\") as f:\n",
        "    f.write(\"This is a test.\\n\")\n",
        "    f.write(\"I repeat, this is a test.\\n\")\n",
        "\n",
        "with open(\"test.txt\") as f:\n",
        "    for line in f.readlines():\n",
        "        line = line.rstrip(\"\\n\")\n",
        "        print(f\"[{line}]\")\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SQg2lDpRW_2R"
      },
      "source": [
        "Alternatively, you can read the whole file into a string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FKRtde6dXDpe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d2728d54-ead8-4201-b4d5-51e281a5fda1"
      },
      "source": [
        "open(\"test.txt\") do f\n",
        "    s = read(f, String)\n",
        "end"
      ],
      "execution_count": 261,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"This is a test.\\nI repeat, this is a test.\\n\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 261
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5vxOQnwucbIW"
      },
      "source": [
        "Or more concisely:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2s-SRVw7cc5G",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "48df2601-a37f-405e-ddb4-814662a33af3"
      },
      "source": [
        "s = read(\"test.txt\", String)"
      ],
      "execution_count": 262,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"This is a test.\\nI repeat, this is a test.\\n\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 262
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dHb_f2lWXM0Z"
      },
      "source": [
        "The Python equivalent is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "with open(\"test.txt\") as f:\n",
        "    s = f.read()\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EmBI1zY8DAvT"
      },
      "source": [
        "# Exceptions\n",
        "\n",
        "Julia's exceptions behave very much like in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z-dXwra9cvYD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3d38d756-2659-4dc1-a342-ece7578e20c2"
      },
      "source": [
        "a = [1]\n",
        "try\n",
        "    push!(a, 2)\n",
        "    #throw(\"Oops\") # try uncommenting this line\n",
        "    push!(a, 3)\n",
        "catch ex\n",
        "    println(ex)\n",
        "    push!(a, 4)\n",
        "finally\n",
        "    push!(a, 5)\n",
        "end\n",
        "println(a)"
      ],
      "execution_count": 263,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kt2mWkKFfd8I"
      },
      "source": [
        "The equivalent Python code is:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "a = [1]\n",
        "try:\n",
        "    a.append(2)\n",
        "    #raise Exception(\"Oops\") # try uncommenting this line\n",
        "    a.append(3)\n",
        "except Exception as ex:\n",
        "    print(ex)\n",
        "    a.append(4)\n",
        "finally:\n",
        "    a.append(5)\n",
        "\n",
        "print(a)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "19zE5t7nhtCJ"
      },
      "source": [
        "There is a whole hierarchy of standard exceptions which can be thrown, just like in Python. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "71J-OuM5h9cr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3b8830c1-2d42-43e2-f404-2bb4e85edf9a"
      },
      "source": [
        "choice = 1 # try changing this value (from 1 to 4)\n",
        "try\n",
        "    choice == 1 && open(\"/foo/bar/i_dont_exist.txt\")\n",
        "    choice == 2 && sqrt(-1)\n",
        "    choice == 3 && push!(a, \"Oops\")\n",
        "    println(\"Everything worked like a charm\")\n",
        "catch ex\n",
        "    if ex isa SystemError\n",
        "        println(\"Oops. System error #$(ex.errnum) ($(ex.prefix))\")\n",
        "    elseif ex isa DomainError\n",
        "        println(\"Oh no, I could not compute sqrt(-1)\")\n",
        "    else\n",
        "        println(\"I got an unexpected error: $ex\")\n",
        "    end\n",
        "end"
      ],
      "execution_count": 264,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Oops. System error #2 (opening file \"/foo/bar/i_dont_exist.txt\")\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0IegY5XckWET"
      },
      "source": [
        "Compare this with Python's equivalent code:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "choice = 3 # try changing this value (from 1 to 4)\n",
        "try:\n",
        "  if choice == 1:\n",
        "      open(\"/foo/bar/i_dont_exist.txt\")\n",
        "  if choice == 2:\n",
        "      math.sqrt(-1)\n",
        "  if choice == 3:\n",
        "      #a.append(\"Ok\") # this would actually work\n",
        "      raise TypeError(\"Oops\") # so let's fail manually\n",
        "  print(\"Everything worked like a charm\")\n",
        "except OSError as ex:\n",
        "    print(f\"Oops. OS error (#{ex.errno} ({ex.strerror})\")\n",
        "except ValueError:\n",
        "    print(\"Oh no, I could not compute sqrt(-1)\")\n",
        "except Exception as ex:\n",
        "    print(f\"I got an unexpected error: {ex}\")\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jD6j5HsCHXzo"
      },
      "source": [
        "A few things to note here:\n",
        "\n",
        "* Julia only allows a single `catch` block which handles all possible exceptions.\n",
        "* `obj isa SomeClass` is a shorthand for `isa(obj, SomeClass)` which is equivalent to Python's `isinstance(obj, SomeClass)`.\n",
        "\n",
        "|Julia|Python\n",
        "|-----|------\n",
        "|`try`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`catch ex`<br />&nbsp;&nbsp;&nbsp;&nbsp;`if ex isa SomeError`<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />&nbsp;&nbsp;&nbsp;&nbsp;`else`<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />&nbsp;&nbsp;&nbsp;&nbsp;`end`<br />`finally`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`end` | `try:`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`except SomeException as ex:`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`except Exception as ex:`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`<br />`finally:`<br />&nbsp;&nbsp;&nbsp;&nbsp;`...`\n",
        "|`throw any_value` | `raise SomeException(...)`\n",
        "| `obj isa SomeType`<br />or<br /> `isa(obj, SomeType`) | `isinstance(obj, SomeType)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lFGQZmkfQg6K"
      },
      "source": [
        "Note that Julia does not support the equivalent of Python's `try / catch / else` construct. You need to write something like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P2qPhf-EQ4WW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab40afbb-cb97-4847-94c1-930d12f7267a"
      },
      "source": [
        "catch_exception = true\n",
        "try\n",
        "    println(\"Try something\")\n",
        "    #error(\"ERROR: Catch me!\") # try uncommenting this line\n",
        "    catch_exception = false\n",
        "    #error(\"ERROR: Don't catch me!\") # try uncommenting this line\n",
        "    println(\"No error occurred\")\n",
        "catch ex\n",
        "    if catch_exception\n",
        "        println(\"I caught this exception: $ex\")\n",
        "    else\n",
        "        throw(ex)\n",
        "    end\n",
        "finally\n",
        "    println(\"The end\")\n",
        "end\n",
        "println(\"After the end\")"
      ],
      "execution_count": 265,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Try something\n",
            "No error occurred\n",
            "The end\n",
            "After the end\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XNyuFEVER7-p"
      },
      "source": [
        "The equivalent Python code is shorter, but it's fairly uncommon:\n",
        "\n",
        "```python\n",
        "# PYTHON\n",
        "try:\n",
        "    print(\"Try something\")\n",
        "    raise Exception(\"Catch me!\") # try uncommenting this line\n",
        "except Exception as ex:\n",
        "    print(f\"I caught this exception: {ex}\")\n",
        "else:\n",
        "    raise Exception(\"Don't catch me!\") # try uncommenting this line\n",
        "    print(\"No error occured\")\n",
        "finally:\n",
        "    print(\"The end\")\n",
        "\n",
        "print(\"After the end\")\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ieqz4vrxEAQb"
      },
      "source": [
        "# Docstrings\n",
        "It's good practice to add docstrings to every function you export. The docstring is placed just _before_ the definition of the function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OgwehsQjNj8Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fbe4fe4b-47f6-467d-a311-8744f88e8f2a"
      },
      "source": [
        "\"Compute the square of number x\"\n",
        "square(x::Number) = x^2"
      ],
      "execution_count": 266,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "square"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 266
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B9vmLpLpO6ix"
      },
      "source": [
        "You can retrieve a function's docstring using the `@doc` macro:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rYR63pL1NsWU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 46
        },
        "outputId": "99613972-c9a9-4898-86b0-dae41aa07e5e"
      },
      "source": [
        "@doc square"
      ],
      "execution_count": 267,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/latex": "Compute the square of number x\n\n",
            "text/markdown": "Compute the square of number x\n",
            "text/plain": [
              "  Compute the square of number x"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 267
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HcKzENGnO-8z"
      },
      "source": [
        "The docstring is displayed when asking for help:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O9xkw7uvNw9A",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 80
        },
        "outputId": "0ec08bf0-3fdb-4d78-e035-2a3a73c33761"
      },
      "source": [
        "?square"
      ],
      "execution_count": 268,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "search: \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mq\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1me\u001b[22m \u001b[0m\u001b[1mS\u001b[22m\u001b[0m\u001b[1mq\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1me\u001b[22m \u001b[0m\u001b[1mS\u001b[22m\u001b[0m\u001b[1mq\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1me\u001b[22m_v2 My\u001b[0m\u001b[1mS\u001b[22m\u001b[0m\u001b[1mq\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1me\u001b[22ms Ab\u001b[0m\u001b[1ms\u001b[22mtractS\u001b[0m\u001b[1mq\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1me\u001b[22m la\u001b[0m\u001b[1ms\u001b[22mtdayof\u001b[0m\u001b[1mq\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22mt\u001b[0m\u001b[1me\u001b[22mr\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/latex": "Compute the square of number x\n\n",
            "text/markdown": "Compute the square of number x\n",
            "text/plain": [
              "  Compute the square of number x"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 268
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wte1Y76jPKpd"
      },
      "source": [
        "Docstrings follow the [Markdown format](https://en.wikipedia.org/wiki/Markdown#:~:text=Markdown%20is%20a%20lightweight%20markup,using%20a%20plain%20text%20editor.).\n",
        "A typical docstring starts with the signature of the function, indented by 4 spaces, so it will get syntax highlighted as Julia code.\n",
        "It also includes an `Examples` section with Julia REPL outputs:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xucdR5ywNzTf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df1b56b6-02b3-4abe-9d3f-40eb1b24f1df"
      },
      "source": [
        "\"\"\"\n",
        "    cube(x::Number)\n",
        "\n",
        "Compute the cube of `x`.\n",
        "\n",
        "# Examples\n",
        "```julia-repl\n",
        "julia> cube(5)\n",
        "125\n",
        "julia> cube(im)\n",
        "0 - 1im\n",
        "```\n",
        "\"\"\"\n",
        "cube(x) = x^3"
      ],
      "execution_count": 269,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "cube"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 269
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b2aSKGYkaN7D"
      },
      "source": [
        "Instead of using `julia-repl` code blocks for the examples, you can use `jldoctest` to mark these examples as doctests (similar to Python's doctests)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gJt_pU7oQFzT"
      },
      "source": [
        "The help gets nicely formatted:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FolAC9NdOYlH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 216
        },
        "outputId": "0cbe4949-0132-4068-c048-b485e635cf3a"
      },
      "source": [
        "?cube"
      ],
      "execution_count": 270,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "search: \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mb\u001b[22m\u001b[0m\u001b[1me\u001b[22m \u001b[0m\u001b[1mC\u001b[22mdo\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mb\u001b[22ml\u001b[0m\u001b[1me\u001b[22m\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/latex": "\\begin{verbatim}\ncube(x::Number)\n\\end{verbatim}\nCompute the cube of \\texttt{x}.\n\n\\section{Examples}\n\\begin{verbatim}\njulia> cube(5)\n125\njulia> cube(im)\n0 - 1im\n\\end{verbatim}\n",
            "text/markdown": "```\ncube(x::Number)\n```\n\nCompute the cube of `x`.\n\n# Examples\n\n```julia-repl\njulia> cube(5)\n125\njulia> cube(im)\n0 - 1im\n```\n",
            "text/plain": [
              "\u001b[36m  cube(x::Number)\u001b[39m\n",
              "\n",
              "  Compute the cube of \u001b[36mx\u001b[39m.\n",
              "\n",
              "\u001b[1m  Examples\u001b[22m\n",
              "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
              "\n",
              "\u001b[36m  julia> cube(5)\u001b[39m\n",
              "\u001b[36m  125\u001b[39m\n",
              "\u001b[36m  julia> cube(im)\u001b[39m\n",
              "\u001b[36m  0 - 1im\u001b[39m"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 270
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bT28xCa9QMcq"
      },
      "source": [
        "When there are several methods for a given function, it is common to give general information about the function in the first method (usually the most generic), and only add docstrings to other methods if they add useful information (without repeating the general info).\n",
        "\n",
        "Alternatively, you may attach the general information to the function itself:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mi3rw1dYQmkT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c69340b-6d91-49d0-f05d-fa1ff2831bf5"
      },
      "source": [
        "\"\"\"\n",
        "    foo(x)\n",
        "\n",
        "Compute the foo of the bar\n",
        "\"\"\"\n",
        "function foo end  # declares the foo function\n",
        "\n",
        "# foo(x::Number) behaves normally, no need for a docstring\n",
        "foo(x::Number) = \"baz\"\n",
        "\n",
        "\"\"\"\n",
        "    foo(x::String)\n",
        "\n",
        "For strings, compute the qux of the bar instead.\n",
        "\"\"\"\n",
        "foo(x::String) = \"qux\""
      ],
      "execution_count": 271,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "foo"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 271
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ffQK0fnPTXsH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        },
        "outputId": "04852f52-c662-41f1-e4c4-528439d3b817"
      },
      "source": [
        "?foo"
      ],
      "execution_count": 272,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "search: \u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mo\u001b[22m \u001b[0m\u001b[1mf\u001b[22ml\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mo\u001b[22mr pointer_\u001b[0m\u001b[1mf\u001b[22mr\u001b[0m\u001b[1mo\u001b[22mm_\u001b[0m\u001b[1mo\u001b[22mbjref wait\u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1mo\u001b[22mrbutt\u001b[0m\u001b[1mo\u001b[22mnpress Over\u001b[0m\u001b[1mf\u001b[22ml\u001b[0m\u001b[1mo\u001b[22mwErr\u001b[0m\u001b[1mo\u001b[22mr\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/latex": "\\begin{verbatim}\nfoo(x)\n\\end{verbatim}\nCompute the foo of the bar\n\n\\rule{\\textwidth}{1pt}\n\\begin{verbatim}\nfoo(x::String)\n\\end{verbatim}\nFor strings, compute the qux of the bar instead.\n\n",
            "text/markdown": "```\nfoo(x)\n```\n\nCompute the foo of the bar\n\n---\n\n```\nfoo(x::String)\n```\n\nFor strings, compute the qux of the bar instead.\n",
            "text/plain": [
              "\u001b[36m  foo(x)\u001b[39m\n",
              "\n",
              "  Compute the foo of the bar\n",
              "\n",
              "  ────────────────────────────────────────────────────────────────────────────\n",
              "\n",
              "\u001b[36m  foo(x::String)\u001b[39m\n",
              "\n",
              "  For strings, compute the qux of the bar instead."
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 272
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K80HBr5oGzo7"
      },
      "source": [
        "# Macros"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QObp7sGRu6UJ"
      },
      "source": [
        "We have seen a few macros already: `@which`, `@assert`, `@time`, `@benchmark`, `@btime` and `@doc`. You guessed it: all macros start with an `@` sign.\n",
        "\n",
        "What is a macro? It is a function which can fully inspect the expression that follows it, and apply any transformation to that code at parse time, before compilation.\n",
        "\n",
        "This makes it possible for anyone to effectively extend the language in any way they please. Whereas C/C++ macros just do simple text replacement, **Julia macros are powerful meta-programming tools**.\n",
        "\n",
        "On the flip side, this also means that **each macro has its own syntax and behavior**.\n",
        "\n",
        "**A personal opinion**: in my experience, languages that provide great flexibility typically attract a community of programmers with a tinkering mindset, who will _love_ to experiment with all the fun features the language has to offer. This is great for creativity, but it can also be a nuisance if the community ends up producing too much experimental code, without much care for code reliability, API stability, or even for simplicity. By all means, let's be creative, let's experiment, but _with great power comes great responsibility_: let's also value reliability, stability and simplicity.\n",
        "\n",
        "That said, to give you an idea of what macro definitions look like in Julia, here's a simple toy macro that replaces `a + b` expressions with `a - b`, and leaves other expressions alone."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "piHUqhKBZGqu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "62fb423b-76c7-4e90-c616-349ceebc3fdb"
      },
      "source": [
        "macro addtosub(x)\n",
        "  if x.head == :call && x.args[1] == :+ && length(x.args) == 3\n",
        "    Expr(:call, :-, x.args[2], x.args[3])\n",
        "  else\n",
        "    x\n",
        "  end\n",
        "end\n",
        "\n",
        "@addtosub 10 + 2"
      ],
      "execution_count": 273,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 273
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7rJOpjunbOFk"
      },
      "source": [
        "In this macro definition, `:call`, `:+` and `:-` are **symbols**. These are similar to strings, only more efficient and less flexible. They are typically used as identifiers, such as keys in dictionaries."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MaXNB30jZ0o9"
      },
      "source": [
        "If you're curious, the macro works because the parser converts `10 + 2` to `Expr(:call, :+, 10, 2)` and passes this expression to the macro (before compilation). The `if` statement checks that the expression is a function call, where the called function is the `+` function, with two arguments. If so, then the macro returns a new expression, corresponding to a call to the `-` function, with the same arguments. So `a + b` becomes `a - b`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tDEx5z5thmJG"
      },
      "source": [
        "For more info, check out [this page](https://docs.julialang.org/en/v1/manual/metaprogramming/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MKMAu-SPGaEp"
      },
      "source": [
        "## Special Prefixed Strings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RiczKNd3Evgz"
      },
      "source": [
        "`py\"...\"` strings are defined by the `PyCall` module. Writing `py\"something\"` is equivalent to writing `@py_str \"something\"`. In other words, anyone can write a macro that defines a new kind of prefixed string. For example, if you write the `@ok_str` macro, it will be called when you write `ok\"something\"`.\n",
        "\n",
        "Another example is the `Pkg` module which defines the `@pkg_str` macro: this is why you can use `pkg\"...\"` to interact with the `Pkg` module. This is how `pkg\"add PyCall; precompile;\"` worked (at the end of the very first cell). This downloaded, installed and precompiled the `PyCall` module."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V2DqnxfIS47B"
      },
      "source": [
        "# Modules\n",
        "In Python, a module must be defined in a dedicated file. In Julia, modules are independent from the file system. You can define several modules per file, or define one module across multiple files, it's up to you. Let's create a simple module containing two submodules, each containing a variable and a function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u9tQpD0JS_gm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a78732a7-514e-4cc3-8451-68d0f4c51144"
      },
      "source": [
        "module ModA\n",
        "    pi = 3.14\n",
        "    square(x) = x^2\n",
        "\n",
        "    module ModB\n",
        "        e = 2.718\n",
        "        cube(x) = x^3\n",
        "    end\n",
        "\n",
        "    module ModC\n",
        "        root2 = √2\n",
        "        relu(x) = max(0, x)\n",
        "    end\n",
        "end"
      ],
      "execution_count": 274,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Main.ModA"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 274
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "olgUIIbvYBQq"
      },
      "source": [
        "The default module is `Main`, so whatever we define is put in this module (except when defining a package, as we will see). This is why the `ModA`'s full name is `Main.ModA`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bnP_rALhVlw3"
      },
      "source": [
        "We can now access the contents of these modules by providing the full paths:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IFOTvRKXXVNr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7d71581b-5abc-4278-c85d-28a098711aa5"
      },
      "source": [
        "Main.ModA.ModC.root2"
      ],
      "execution_count": 275,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.4142135623730951"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 275
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z-ooQk9zYY1N"
      },
      "source": [
        "Since our code runs in the `Main` module, we can leave out the `Main.` part:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JnnhVg1eYhLz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81acba97-75da-44e1-9788-4a13d9b71f7f"
      },
      "source": [
        "ModA.ModC.root2"
      ],
      "execution_count": 276,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.4142135623730951"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 276
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7liRTwI2Xd5e"
      },
      "source": [
        "Alternatively, you can use `import`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DxT44ZvnXoGN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "61002bb9-e7e2-441a-e449-68e034184822"
      },
      "source": [
        "import Main.ModA.ModC.root2\n",
        "\n",
        "root2"
      ],
      "execution_count": 277,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.4142135623730951"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 277
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TpOjKGi8Ymmu"
      },
      "source": [
        "Or we can use `import` with a relative path. In this case, we need to prefix `ModA` with a dot `.` to indicate that we want the module `ModA` located in the current module:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9kqmiNNTYpQY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "31f15074-b4d6-4202-ec7b-4de6f3f16391"
      },
      "source": [
        "import .ModA.ModC.root2\n",
        "\n",
        "root2"
      ],
      "execution_count": 278,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.4142135623730951"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 278
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U1jBsBSyYshg"
      },
      "source": [
        "Alternatively, we can `import` the submodule:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Xui2RQEZROC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "65be0473-15fb-4adc-f953-c355b89ab82e"
      },
      "source": [
        "import .ModA.ModC\n",
        "\n",
        "ModC.root2"
      ],
      "execution_count": 279,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.4142135623730951"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 279
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8mz_KKlAZXPH"
      },
      "source": [
        "When you want to import more than one name from a module, you can use this syntax:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qtmDevYgZh5I"
      },
      "source": [
        "import .ModA.ModC: root2, relu"
      ],
      "execution_count": 280,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T1nyVSefZotn"
      },
      "source": [
        "This is equivalent to this more verbose syntax:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s-i-7QIGZrQn"
      },
      "source": [
        "import .ModA.ModC.root2, .ModA.ModC.relu"
      ],
      "execution_count": 281,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rJSA9aljZ3BN"
      },
      "source": [
        "Nested modules do <u>not</u> automatically have access to names in enclosing modules. To import names from a parent module, use `..x`. From a grand-parent module, use `...x`, and so on."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NvRtf5SWZ_Wk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "012f17cc-f7b7-4be7-9812-63d580222b7c"
      },
      "source": [
        "module ModD\n",
        "    d = 1\n",
        "    module ModE\n",
        "        try\n",
        "            println(d)\n",
        "        catch ex\n",
        "            println(ex)\n",
        "        end\n",
        "    end\n",
        "    module ModF\n",
        "        f = 2\n",
        "        module ModG\n",
        "            import ..f\n",
        "            import ...d\n",
        "            println(f)\n",
        "            println(d)\n",
        "        end\n",
        "    end\n",
        "end"
      ],
      "execution_count": 282,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "UndefVarError(:d)\n",
            "2\n",
            "1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Main.ModD"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 282
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_YxkO1ebZEb"
      },
      "source": [
        "Instead of `import`, you can use `using`. It is analog to Python's `from foo import *`. It only gives access to names which were explicitly exported using `export` (similar to the way `from foo import *` in Python only imports names listed in the module's `__all__` list):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CNDHFWv2blSk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a7b82c9-4658-49ba-92bb-affcb017fc24"
      },
      "source": [
        "module ModH\n",
        "    h1 = 1\n",
        "    h2 = 2\n",
        "    export h1\n",
        "end"
      ],
      "execution_count": 283,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Main.ModH"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 283
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TrlkNAZjcDpv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ab5aa1c-b780-4f40-9c30-c97700d3a32e"
      },
      "source": [
        "using .ModH\n",
        "\n",
        "println(h1)\n",
        "\n",
        "try\n",
        "    println(h2)\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 284,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "UndefVarError(:h2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 284
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XA-8xz9XBkFr"
      },
      "source": [
        "Note that `using Foo` not only imports all exported names (like Python's `from foo import *`), it also imports `Foo` itself (similarly, `using Foo.Bar` imports `Bar` itself):\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b2j0lGheB4DK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3319e316-87da-479c-9705-5779adfd43da"
      },
      "source": [
        "ModH"
      ],
      "execution_count": 285,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Main.ModH"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 285
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZJr74QBRzuEo"
      },
      "source": [
        "Even if a name is not exported, you can always access it using its full path, or using `import`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yjCkh4voz44p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e921e1c0-2b92-4b81-8702-49b74d5f4022"
      },
      "source": [
        "ModH.h2"
      ],
      "execution_count": 286,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 286
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SAL1D1dRz7oy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "29a2df9d-5126-480a-8800-91927d560b46"
      },
      "source": [
        "import .ModH.h2\n",
        "\n",
        "h2"
      ],
      "execution_count": 287,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 287
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1UfcZp6fcNdT"
      },
      "source": [
        "You can also import individual names like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fQPAWJMRzOmj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3479256c-e7f1-4cd4-9dca-19900869adcc"
      },
      "source": [
        "module ModG\n",
        "    g1 = 1\n",
        "    g2 = 2\n",
        "    export g2\n",
        "end\n",
        "\n",
        "using .ModG: g1, g2\n",
        "\n",
        "println(g1)\n",
        "println(g2)"
      ],
      "execution_count": 288,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y5ToJpN_0RMa"
      },
      "source": [
        "Notice that this syntax gives you access to any name you want, whether or not it was exported. In other words, whether a name is exported or not only affects the `using Foo` syntax."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yzXfmlAg0diH"
      },
      "source": [
        "Importantly, when you want to expand a function which is defined in a module, you must import the function using `import`, or you must specify the function's path:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BfOgteoF0m4X",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "083decc6-dad1-4956-dc90-4e265d8aae44"
      },
      "source": [
        "module ModH\n",
        "    double(x) = x * 2\n",
        "    triple(x) = x * 3\n",
        "end\n",
        "\n",
        "import .ModH: double\n",
        "double(x::AbstractString) = repeat(x, 2)\n",
        "\n",
        "ModH.triple(x::AbstractString) = repeat(x, 3)\n",
        "\n",
        "println(double(2))\n",
        "println(double(\"Two\"))\n",
        "\n",
        "println(ModH.triple(3))\n",
        "println(ModH.triple(\"Three\"))"
      ],
      "execution_count": 289,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n",
            "TwoTwo\n",
            "9\n",
            "ThreeThreeThree\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "WARNING: replacing module ModH.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c4c2yTaS7fvj"
      },
      "source": [
        "You must never extend a function imported with `using`, unless you provide the function's path:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "18mmhRsP18o_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "61165a2b-d809-4b88-a9b6-e7578c84080c"
      },
      "source": [
        "module ModI\n",
        "    quadruple(x) = x * 4\n",
        "    export quadruple\n",
        "end\n",
        "\n",
        "using .ModI\n",
        "ModI.quadruple(x::AbstractString) = repeat(x, 4) # OK\n",
        "println(quadruple(4))\n",
        "println(quadruple(\"Four\"))\n",
        "\n",
        "#quadruple(x::AbstractString) = repeat(x, 4) # uncomment to see the error"
      ],
      "execution_count": 290,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "16\n",
            "FourFourFourFour\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0gwWiNqfD-Pp"
      },
      "source": [
        "There is no equivalent of Python's `import foo as x` ([yet](https://github.com/JuliaLang/julia/issues/1255)), but you can do something like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2eGsfHqkEViW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c4580b1b-0d1a-40a3-c86c-64a9d3d351da"
      },
      "source": [
        "import .ModI: quadruple\n",
        "x = quadruple"
      ],
      "execution_count": 291,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "quadruple (generic function with 2 methods)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 291
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pB4HxazHyNiF"
      },
      "source": [
        "In general, a module named `Foo` will be defined in a file named `Foo.jl` (along with its submodules). However, if the module becomes too big for a single file, you can split it into multiple files and include these files in `Foo.jl` using the `include()` function.\n",
        "\n",
        "For example, let's create three files: `Awesome.jl`, `great.jl` and `amazing/Fantastic.jl`, where:\n",
        "* `Awesome.jl` defines the `Awesome` module and includes the other two files\n",
        "* `great.jl` just defines a function\n",
        "* `amazing/Fantastic.jl` defines the `Fantastic` submodule"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A9iOU4XWundK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac0b8b38-35fd-449f-f460-6b5bd33b867f"
      },
      "source": [
        "code_awesome = \"\"\"\n",
        "module Awesome\n",
        "include(\"great.jl\")\n",
        "include(\"amazing/Fantastic.jl\")\n",
        "end\n",
        "\"\"\"\n",
        "\n",
        "code_great = \"\"\"\n",
        "great() = \"This is great!\"\n",
        "\"\"\"\n",
        "\n",
        "code_fantastic = \"\"\"\n",
        "module Fantastic\n",
        "fantastic = true\n",
        "end\n",
        "\"\"\"\n",
        "\n",
        "open(f->write(f, code_awesome), \"Awesome.jl\", \"w\")\n",
        "open(f->write(f, code_great), \"great.jl\", \"w\")\n",
        "mkdir(\"amazing\")\n",
        "open(f->write(f, code_fantastic), \"amazing/Fantastic.jl\", \"w\")"
      ],
      "execution_count": 292,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "38"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 292
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3OYEv-P-xGHg"
      },
      "source": [
        "If we try to execute `import Awesome` now, it won't work since Julia does not search in the current directory by default. Let's change this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zz-JHOzXxZj5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "565adaf6-865d-412d-d8aa-4c328b76c0b1"
      },
      "source": [
        "pushfirst!(LOAD_PATH, \".\")"
      ],
      "execution_count": 293,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{String}:\n",
              " \".\"\n",
              " \"@\"\n",
              " \"@v#.#\"\n",
              " \"@stdlib\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 293
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L8H2XLMAww7g"
      },
      "source": [
        "Now when we import the `Awesome` module, Julia will look for a file named `Awesome.jl` in the current directory, or for `Awesome/src/Awesome.jl`, or for `Awesome.jl/src/Awesome.jl`. If it does not find any of these, it will look in the other places listed in the `LOAD_PATH` array (we will discuss this in more details in the \"Package Management\" section)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V4crjErQvuYf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3c973fd9-67ef-4705-f329-bf327c4de135"
      },
      "source": [
        "import Awesome\n",
        "println(Awesome.great())\n",
        "println(\"Is fantastic? \", Awesome.Fantastic.fantastic)"
      ],
      "execution_count": 294,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "┌ Info: Precompiling Awesome [top-level]\n",
            "└ @ Base loading.jl:1317\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "This is great!\n",
            "Is fantastic? true\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zpLsSNQbttj1"
      },
      "source": [
        "Let's restore the original `LOAD_PATH`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zV4wd4Natxw7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2f841a91-03ab-4de0-dd24-70c756b8d3d8"
      },
      "source": [
        "popfirst!(LOAD_PATH)"
      ],
      "execution_count": 295,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\".\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 295
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jz7_FaJcaZn-"
      },
      "source": [
        "In short:\n",
        "\n",
        "|Julia | Python\n",
        "|------|-------\n",
        "|`import Foo` | `import foo`\n",
        "|`import Foo.Bar` | `from foo import bar`\n",
        "|`import Foo.Bar: a, b` | `from foo.bar import a, b`\n",
        "|`import Foo.Bar.a, Foo.Bar.b` | `from foo.bar import a, b`\n",
        "|`import .Foo` | `import .foo`\n",
        "|`import ..Foo.Bar` | `from ..foo import bar`\n",
        "|`import ...Foo.Bar` | `from ...foo import bar`\n",
        "|`import .Foo: a, b` | `from .foo import a, b`\n",
        "||\n",
        "|`using Foo` | `from foo import *; import foo`\n",
        "|`using Foo.Bar` | `from foo.bar import *; from foo import bar `\n",
        "|`using Foo.Bar: a, b` | `from foo.bar import a, b`\n",
        "\n",
        "|Extending function `Foo.f()` | Result\n",
        "|-----------------------------|--------\n",
        "|`import Foo.f  # or Foo: f` <br />`f(x::Int64) = ...`  | OK\n",
        "|`import Foo`<br />`Foo.f(x::Int64) = ...` | OK\n",
        "|`using Foo`<br />`Foo.f(x::Int64) = ...` | OK\n",
        "|`import Foo.f # or Foo: f`<br />`Foo.f(x::Int64) = ...` | `ERROR: Foo not defined`\n",
        "|`using Foo`<br />`f(x::Int64) = ...` | `ERROR: Foo.f must be explicitly imported`\n",
        "|`using Foo: f`<br />`f(x::Int64) = ...` | `ERROR: Foo.f must be explicitly imported`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Inpk8qS3HL_u"
      },
      "source": [
        "# Scopes\n",
        "Julia has two types of scopes: global and local.\n",
        "\n",
        "Every module has its own global scope, independent from all other global scopes. There is no overarching global scope.\n",
        "\n",
        "Modules, macros and types (including structs) can only be defined in a global scope.\n",
        "\n",
        "Most code blocks, including `function`, `struct`, `for`, `while`, etc., have their own local scope. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q3Lm3T1DG6St",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bd70a17c-b01a-4a03-92cd-287fb42b2596"
      },
      "source": [
        "for q in 1:3\n",
        "    println(q)\n",
        "end\n",
        "\n",
        "try\n",
        "    println(q) # q is not available here\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 296,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "UndefVarError(:q)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 296
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wh6xa4fyJLYY"
      },
      "source": [
        "A local scope inherits from its parent scope:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IeLfjf4ZJQ41",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81d96978-dba2-4507-c6cc-118cb2ff9eb4"
      },
      "source": [
        "z = 5\n",
        "for i in 1:3\n",
        "    w = 10\n",
        "    println(i * w * z) # i and w are local, z is from the parent scope\n",
        "end"
      ],
      "execution_count": 297,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "50\n",
            "100\n",
            "150\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OQLfwoD3NoC_"
      },
      "source": [
        "An inner scope can assign to a variable in the parent scope, if the parent scope is not global:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fwN1C2BhNxyZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "68f6ca68-633e-470d-c1e9-569f8b48aac1"
      },
      "source": [
        "for i in 1:3\n",
        "    s = 0\n",
        "    for j in 1:5\n",
        "        s = j # variable s is from the parent scope\n",
        "    end\n",
        "    println(s)\n",
        "end"
      ],
      "execution_count": 298,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "5\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0m3aoj8UKxS4"
      },
      "source": [
        "You can force a variable to be local by using the `local` keyword:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hlireAo6K3eS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "54bf01b6-9b56-4f4d-d97f-f1c39ff6864b"
      },
      "source": [
        "for i in 1:3\n",
        "    s = 0\n",
        "    for j in 1:5\n",
        "        local s = j # variable s is local now\n",
        "    end\n",
        "    println(s)\n",
        "end"
      ],
      "execution_count": 299,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "0\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qwo2DWNIN8oR"
      },
      "source": [
        "To assign to a global variable, you must declare the variable as `global` in the local scope:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rPnibZjLOFHv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "364a7b0c-141e-448f-9ec7-c472aac6df7e"
      },
      "source": [
        "for i in 1:3\n",
        "    global p\n",
        "    p = i\n",
        "end\n",
        "p"
      ],
      "execution_count": 300,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 300
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tL5AgzVjOKuo"
      },
      "source": [
        "There is one exception to this rule: when executing code directly in the REPL (since Julia 1.5) or in IJulia, you do not need to declare a variable as `global` if the global variable already exists:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PKZPY8XOOlT9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "91fe8fa1-3c39-4f0d-faef-14966aa84c7e"
      },
      "source": [
        "s = 0\n",
        "for i in 1:3\n",
        "    s = i # implicitly global s: only in REPL Julia 1.5+ or IJulia\n",
        "end\n",
        "s"
      ],
      "execution_count": 301,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 301
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ne7zn3qgPo6M"
      },
      "source": [
        "In functions, assigning to a variable which is not explicitly declared as global always makes it local (even in the REPL and IJulia):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RJgKv_6oPhH2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "275c8c06-72bd-4594-faa0-4bdbc562f84e"
      },
      "source": [
        "s, t = 1, 2 # globals\n",
        "\n",
        "function foo()\n",
        "   s = 10 * t # s is local, t is global\n",
        "end\n",
        "\n",
        "println(foo())\n",
        "println(s)"
      ],
      "execution_count": 302,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "20\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DhnbEml6SiTG"
      },
      "source": [
        "Just like in Python, functions can capture variables from the enclosing scope (not from the scope the function is called from):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B1lAq94XS6yX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1d6d31b9-18d5-499e-c8fa-57c7e8c99847"
      },
      "source": [
        "t = 1\n",
        "\n",
        "foo() = t # foo() captures t from the global scope\n",
        "\n",
        "function bar()\n",
        "    t = 5 # this is a new local variable\n",
        "    println(foo()) # foo() still uses t from the global scope\n",
        "end\n",
        "\n",
        "bar()"
      ],
      "execution_count": 303,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a460UCKFTXt7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "59e06d37-f432-4f2f-cd75-f90ac590f65f"
      },
      "source": [
        "function quz()\n",
        "    global t\n",
        "    t = 5 # we change the global t\n",
        "    println(foo()) # and this affects foo()\n",
        "end\n",
        "\n",
        "quz()"
      ],
      "execution_count": 304,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MKsqCB48UxiU"
      },
      "source": [
        "Closures work much like in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CvyNc-ksT22C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ebb0e464-a6a4-4cce-957d-0e36b18d4a57"
      },
      "source": [
        "function create_multiplier(n)\n",
        "    function mul(x)\n",
        "        x * n # variable n is captured from the parent scope\n",
        "    end\n",
        "end\n",
        "\n",
        "mul2 = create_multiplier(2)\n",
        "mul2(5)"
      ],
      "execution_count": 305,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 305
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5qAMInDsUtJN"
      },
      "source": [
        "An inner function can modify variables from its parent scope:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s0JpWoqcU9-P",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5e3f3f26-7c8c-482c-b006-ee91e9ae2e80"
      },
      "source": [
        "function create_counter()\n",
        "    c = 0\n",
        "    inc() = c += 1 # this inner function modifies the c from the outer function\n",
        "end\n",
        "\n",
        "cnt = create_counter()\n",
        "println(cnt())\n",
        "println(cnt())"
      ],
      "execution_count": 306,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ai7b0ZAlrjT"
      },
      "source": [
        "Consider the following code, and see if you can figure out why it prints the same result multiple times:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eEe2LtvSl0Ea",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c7098a0-c090-4db1-a23a-0711e25fc05f"
      },
      "source": [
        "funcs = []\n",
        "i = 1\n",
        "while i ≤ 5\n",
        "    push!(funcs, ()->i^2)\n",
        "    global i += 1\n",
        "end\n",
        "for fn in funcs\n",
        "    println(fn())\n",
        "end"
      ],
      "execution_count": 307,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "36\n",
            "36\n",
            "36\n",
            "36\n",
            "36\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ryvtm8pImQlB"
      },
      "source": [
        "The answer is that there is a single variable `i`, which is captured by all 5 closures. By the time these closures are executed, the value of `i` is 6, so the square is 36, for every closure."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PWkRl2Yfm4A8"
      },
      "source": [
        "If we use a `for` loop, we don't have this problem, since a new local variable is created at every iteration:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zRrKzMHjnBD_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "54f283f9-4811-4c55-edfb-8b3f9f031a27"
      },
      "source": [
        "funcs = []\n",
        "for i in 1:5\n",
        "    push!(funcs, ()->i^2)\n",
        "end\n",
        "for fn in funcs\n",
        "    println(fn())\n",
        "end"
      ],
      "execution_count": 308,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "4\n",
            "9\n",
            "16\n",
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "URV8meLypzMG"
      },
      "source": [
        "Any local variable created within a `for` loop, a `while` loop or a comprehension also get a new copy at each iteration. So we could code the above example like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xjXXASVEqBim",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6959eaf1-361f-491e-bfd0-a29f788671c7"
      },
      "source": [
        "funcs = []\n",
        "i = 1\n",
        "while i ≤ 5  # since we are in a while loop...\n",
        "    global i\n",
        "    local j = i # ...and j is created here, it's a new `j` at each iteration\n",
        "    push!(funcs, ()->j^2)\n",
        "    i += 1\n",
        "end\n",
        "for fn in funcs\n",
        "    println(fn())\n",
        "end"
      ],
      "execution_count": 309,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "4\n",
            "9\n",
            "16\n",
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vazl0dRDnLpk"
      },
      "source": [
        "Another way to get the same result is to use a `let` block, which also creates a new local variable every time it is executed:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X-HuxLIdnSgB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6eb961b2-6a7d-481b-e034-cb5a366bd0d6"
      },
      "source": [
        "funcs = []\n",
        "i = 0\n",
        "while i < 5\n",
        "    let i=i\n",
        "        push!(funcs, ()->i^2)\n",
        "    end\n",
        "    global i += 1\n",
        "end\n",
        "for fn in funcs\n",
        "    println(fn())\n",
        "end"
      ],
      "execution_count": 310,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "4\n",
            "9\n",
            "16\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fXEf0zs0no--"
      },
      "source": [
        "This `let i=i` block defines a new local variable `i` at every iteration, and initializes it with the value of `i` from the parent scope. Therefore each closure captures a different local variable `i`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TKWWfJacoDU0"
      },
      "source": [
        "Variables in a `let` block are initialized from left to right, so they can access variables on their left:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HPXugdyUoH6R",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aa509795-3c7c-4b4f-a0c5-1ed9a0670bcd"
      },
      "source": [
        "a = 1\n",
        "let a=a+1, b=a\n",
        "    println(\"a=$a, b=$b\")\n",
        "end"
      ],
      "execution_count": 311,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a=2, b=2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S9-frzGloRln"
      },
      "source": [
        "In this example, the local variable `a` is initialized with the value of `a + 1`, where `a` comes from the parent scope (i.e., it's the global `a` in this case). However, `b` is initialized with the value of the local `a`, since it now hides the variable `a` from the parent scope."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SEI5E2xbgYHl"
      },
      "source": [
        "Default values in function arguments also have this left-to-right scoping logic:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S-E8aGtPgBCx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a6646a61-af71-4396-da6c-a6c26c14a109"
      },
      "source": [
        "a = 1\n",
        "foobar(a=a+1, b=a) = println(\"a=$a, b=$b\")\n",
        "foobar()\n",
        "foobar(5)"
      ],
      "execution_count": 312,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a=2, b=2\n",
            "a=5, b=5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PzqwY5FngkML"
      },
      "source": [
        "In this example, the first argument's default value is `a + 1`, where `a` comes from the parent scope (i.e., the global `a` in this case). However, the second argument's default value is `a`, where `a` in this case is the value of the first argument (<u>not</u> the parent scope's `a`)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Au3RUzMsHWw8"
      },
      "source": [
        "Note that `if` blocks and `begin` blocks do <u>not</u> have their own local scope, they just use the parent scope:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iARzIFgtpOfB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1976e1b6-0aea-43e2-8018-f5050969e829"
      },
      "source": [
        "a = 1\n",
        "if true\n",
        "    a = 2 # same `a` as above\n",
        "end\n",
        "a"
      ],
      "execution_count": 313,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 313
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kO5v8sfCHogx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff4a5056-bc96-437a-da91-6663a78839a2"
      },
      "source": [
        "a = 1\n",
        "begin\n",
        "    a = 2  # same `a` as above\n",
        "end\n",
        "a"
      ],
      "execution_count": 314,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 314
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ME2_ryels7L"
      },
      "source": [
        "# Package Management\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hsT_nU1gB6-r"
      },
      "source": [
        "## Basic Workflow\n",
        "The simplest way to write a Julia program is to create a `.jl` file somewhere and run it using `julia`. You would usually do this with your favorite editor, but in this notebook we must do this programmatically. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sRL8oZDaC0PX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "99859a12-d99a-4eeb-b660-5bde420f6392"
      },
      "source": [
        "code = \"\"\"\n",
        "println(\"Hello world\")\n",
        "\"\"\"\n",
        "\n",
        "open(f->write(f, code), \"my_program1.jl\", \"w\")"
      ],
      "execution_count": 315,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "23"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 315
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I3LsIKh47R99"
      },
      "source": [
        "Then let's run the program using a shell command:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UvfGZxERDv6c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a77e71d-9415-4f95-f22d-8b73b9dc57d0"
      },
      "source": [
        ";julia my_program1.jl"
      ],
      "execution_count": 316,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello world\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KmDPtknrD0Al"
      },
      "source": [
        "If you need to use a package which is not part of the standard library, such as `PyCall`, you first need to install it using Julia's package manager `Pkg`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "doKyY1qWEMZV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9f97e61e-99ba-4c7b-9ccf-b0afa77fc466"
      },
      "source": [
        "using Pkg\n",
        "Pkg.add(\"PyCall\")"
      ],
      "execution_count": 317,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n",
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Project.toml`\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Manifest.toml`\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iQj8OgUKERBz"
      },
      "source": [
        "Alternatively, in interactive mode, you can enter the `Pkg` mode by typing `]`, then type a command:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KGyakk8GEf84",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b2d6a186-add9-410a-ceba-45793e739b3b"
      },
      "source": [
        "]add PyCall"
      ],
      "execution_count": 318,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Project.toml`\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Manifest.toml`\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AsGGVOPzEkj9"
      },
      "source": [
        "You can also precompile the new package to avoid the compilation delay when the package is first used:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GqYovSwVEihb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d5748063-1dbb-4b1c-f623-23ae35d17b52"
      },
      "source": [
        "]add PyCall; precompile;"
      ],
      "execution_count": 319,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Project.toml`\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Manifest.toml`\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JMwXNbzGExCn"
      },
      "source": [
        "One last alternative is to use `pkg\"...\"` strings to run commands in your programs:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tx5hdeO9E71F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a77f8002-0d1c-4a94-820e-7b8f87b768fe"
      },
      "source": [
        "pkg\"add PyCall; precompile;\""
      ],
      "execution_count": 320,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Project.toml`\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Manifest.toml`\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fEIWFBgnFC6c"
      },
      "source": [
        "Now you can import `PyCall` in any of your Julia programs:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9kTp497AFJuT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a319d2c5-7f4a-4e9e-c625-e42983ec9159"
      },
      "source": [
        "code = \"\"\"\n",
        "using PyCall\n",
        "py\"print('1 + 2 =', 1 + 2)\"\n",
        "\"\"\"\n",
        "\n",
        "open(f->write(f, code), \"my_program2.jl\", \"w\")"
      ],
      "execution_count": 321,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "41"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 321
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "unfHQR31FVf1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8765277-134d-406d-86fb-296aba428522"
      },
      "source": [
        ";julia my_program2.jl"
      ],
      "execution_count": 322,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 + 2 = 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Cd3wPG9PH-p"
      },
      "source": [
        "You can also add packages by providing their URL (typically on github). This is useful when you want to use a package which is not in the [official Julia Package registry](https://github.com/JuliaRegistries/General), or when you want the very latest version of a package:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cW6k8F91PT23",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "435aaa3c-391c-4b53-9fa4-75cd4bd34da2"
      },
      "source": [
        "]add https://github.com/JuliaLang/Example.jl"
      ],
      "execution_count": 323,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m     Cloning\u001b[22m\u001b[39m git-repo `https://github.com/JuliaLang/Example.jl`\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaLang/Example.jl`\n",
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[92m+ Example v0.5.4 `https://github.com/JuliaLang/Example.jl#master`\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Manifest.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[92m+ Example v0.5.4 `https://github.com/JuliaLang/Example.jl#master`\u001b[39m\n",
            "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
            "\u001b[32m  ✓ \u001b[39mExample\n",
            "1 dependency successfully precompiled in 1 seconds (42 already precompiled)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HtRAtwWkD3Ao"
      },
      "source": [
        "You can install a specific package version like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CceFEwcTCAWG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5f9d4d46-af5d-4190-d2d9-e9054827813c"
      },
      "source": [
        "]add PyCall@1.91.3"
      ],
      "execution_count": 324,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m PyCall ─ v1.91.3\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Project.toml`\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[95m↓ PyCall v1.92.2 ⇒ v1.91.3\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Manifest.toml`\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[95m↓ PyCall v1.92.2 ⇒ v1.91.3\u001b[39m\n",
            "\u001b[32m\u001b[1m    Building\u001b[22m\u001b[39m PyCall → `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/ce0780857d129208c4e5a6d722486fb40ce11bf8/build.log`\n",
            "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
            "\u001b[32m  ✓ \u001b[39mPyCall\n",
            "\u001b[33m  ? \u001b[39mPyPlot\n",
            "1 dependency successfully precompiled in 5 seconds (41 already precompiled)\n",
            "\u001b[33m1\u001b[39m dependency failed but may be precompilable after restarting julia\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AlN_f9jpGPO1"
      },
      "source": [
        "If you only specify version `1` or version `1.91`, Julia will get the latest version with that prefix. For example, `]add PyCall@0.91` would install the latest version `0.91.x`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TDixUMn7DDri"
      },
      "source": [
        "You can also update a package to its latest version:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0EQofpkzD4xq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9eb7f171-436a-462c-8bd4-4f4eaba3776d"
      },
      "source": [
        "]update PyCall"
      ],
      "execution_count": 325,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Project.toml`\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[93m↑ PyCall v1.91.3 ⇒ v1.92.2\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Manifest.toml`\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[93m↑ PyCall v1.91.3 ⇒ v1.92.2\u001b[39m\n",
            "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
            "\u001b[32m  ✓ \u001b[39mPyCall\n",
            "\u001b[33m  ? \u001b[39mPyPlot\n",
            "1 dependency successfully precompiled in 5 seconds (41 already precompiled)\n",
            "\u001b[33m1\u001b[39m dependency failed but may be precompilable after restarting julia\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lgeDVp26DI7_"
      },
      "source": [
        "You can update all packages to their latest versions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S3Mi-zgLDOVw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "23a16e4c-df4e-4f61-ec21-3ca29a2f3963"
      },
      "source": [
        "]update"
      ],
      "execution_count": 326,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaLang/Example.jl`\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Project.toml`\n",
            "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.6/Manifest.toml`\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1C6nNERsDa_M"
      },
      "source": [
        "If you don't want a particular package to be updated the next time you call `]update`, you can pin it:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nht6o2uCDiiL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b8e5a3b-aa3e-41e8-e446-284639c03bc8"
      },
      "source": [
        "]pin PyCall"
      ],
      "execution_count": 327,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Project.toml`\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[95m↓ PyCall v1.92.2 ⇒ v1.92.2 ⚲\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Manifest.toml`\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[95m↓ PyCall v1.92.2 ⇒ v1.92.2 ⚲\u001b[39m\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qp9v2d7tDxjH"
      },
      "source": [
        "To unpin the package:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3i9JoQimDl7I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a94353d-586a-47af-c7b2-230ab3e7926b"
      },
      "source": [
        "]free PyCall"
      ],
      "execution_count": 328,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Project.toml`\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[95m↓ PyCall v1.92.2 ⚲ ⇒ v1.92.2\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Manifest.toml`\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[95m↓ PyCall v1.92.2 ⚲ ⇒ v1.92.2\u001b[39m\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Asr1snFp609f"
      },
      "source": [
        "You can also run the tests defined in a package:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XlmKnEvf67zi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "44c71c9a-2129-4a99-824d-d4f286bd9444"
      },
      "source": [
        "]test Example"
      ],
      "execution_count": 329,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m     Testing\u001b[22m\u001b[39m Example\n",
            "\u001b[32m\u001b[1m      Status\u001b[22m\u001b[39m `/tmp/jl_GXRm5b/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[37mExample v0.5.4 `https://github.com/JuliaLang/Example.jl#master`\u001b[39m\n",
            " \u001b[90m [8dfed614] \u001b[39m\u001b[37mTest `@stdlib/Test`\u001b[39m\n",
            "\u001b[32m\u001b[1m      Status\u001b[22m\u001b[39m `/tmp/jl_GXRm5b/Manifest.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[37mExample v0.5.4 `https://github.com/JuliaLang/Example.jl#master`\u001b[39m\n",
            " \u001b[90m [2a0f44e3] \u001b[39m\u001b[37mBase64 `@stdlib/Base64`\u001b[39m\n",
            " \u001b[90m [b77e0a4c] \u001b[39m\u001b[37mInteractiveUtils `@stdlib/InteractiveUtils`\u001b[39m\n",
            " \u001b[90m [56ddb016] \u001b[39m\u001b[37mLogging `@stdlib/Logging`\u001b[39m\n",
            " \u001b[90m [d6f4376e] \u001b[39m\u001b[37mMarkdown `@stdlib/Markdown`\u001b[39m\n",
            " \u001b[90m [9a3f8284] \u001b[39m\u001b[37mRandom `@stdlib/Random`\u001b[39m\n",
            " \u001b[90m [9e88b42a] \u001b[39m\u001b[37mSerialization `@stdlib/Serialization`\u001b[39m\n",
            " \u001b[90m [8dfed614] \u001b[39m\u001b[37mTest `@stdlib/Test`\u001b[39m\n",
            "\u001b[32m\u001b[1m     Testing\u001b[22m\u001b[39m Running tests...\n",
            "\u001b[32m\u001b[1m     Testing\u001b[22m\u001b[39m Example tests passed \n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lHAXzij6ZPPs"
      },
      "source": [
        "Of course, you can remove a package:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2fuEjhjzZROg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aad942a3-ad60-4114-b73e-6e5a5ab1f3a3"
      },
      "source": [
        "]rm Example"
      ],
      "execution_count": 330,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[91m- Example v0.5.4 `https://github.com/JuliaLang/Example.jl#master`\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Manifest.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[91m- Example v0.5.4 `https://github.com/JuliaLang/Example.jl#master`\u001b[39m\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eeTA6D33CHTv"
      },
      "source": [
        "Lastly, you can check which packages are installed using `]status` (or `]st` for short):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lSqzm_yECL6Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3363ca77-b3e7-47fb-d86a-2c630da2b3cb"
      },
      "source": [
        "]st"
      ],
      "execution_count": 331,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m      Status\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Project.toml`\n",
            " \u001b[90m [6e4b80f9] \u001b[39m\u001b[37mBenchmarkTools v0.6.0\u001b[39m\n",
            " \u001b[90m [052768ef] \u001b[39m\u001b[37mCUDA v2.6.2\u001b[39m\n",
            " \u001b[90m [7073ff75] \u001b[39m\u001b[37mIJulia v1.23.2\u001b[39m\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[37mPyCall v1.92.2\u001b[39m\n",
            " \u001b[90m [d330b81b] \u001b[39m\u001b[37mPyPlot v2.9.0\u001b[39m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VVwtyjNJlL5j"
      },
      "source": [
        "For more `Pkg` commands, type `]help`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rQY6BRiBvdbU"
      },
      "source": [
        "|Julia (in interactive mode) | Python (in a terminal)\n",
        "|-----|------\n",
        "|`]status` | `pip freeze`<br />or<br />`conda list`\n",
        "|`]add Foo` | `pip install foo`<br />or<br />`conda install foo`\n",
        "|`]add Foo@1.2` | `pip install foo==1.2`<br />or<br />`conda install foo=1.2`\n",
        "|`]update Foo` | `pip install --upgrade foo`<br />or<br />`conda update foo`\n",
        "|`]pin Foo` | `foo==<version>` in `requirements.txt`<br /> or<br />`foo=<version>` in `environment.yml`\n",
        "|`]free Foo` | `foo` in `requirements.txt`<br />or<br />`foo` in `environment.yml`\n",
        "|`]test Foo` | `python -m unittest foo`\n",
        "|`]rm Foo` | `pip uninstall foo`<br />or<br />`conda remove foo`\n",
        "|`]help` | `pip --help`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o6KvuaMcFx2N"
      },
      "source": [
        "This workflow is fairly simple, but it means that all of your programs will be using the same version of each package. This is analog to installing packages using `pip install` without using virtual environments."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CaJvX0RcqukU"
      },
      "source": [
        "\n",
        "## Projects\n",
        "\n",
        "If you want to have multiple projects, each with different libraries and library versions, you should define **projects**. These are analog to Python virtual environments.\n",
        "\n",
        "A project is just a directory containing a `Project.toml` file and a `Manifest.toml` file:\n",
        "\n",
        "```\n",
        "my_project/\n",
        "    Project.toml\n",
        "    Manifest.toml\n",
        "```\n",
        "\n",
        "* `Project.toml` is similar to a `requirements.txt` file (for pip) or `environment.yml` (for conda): it lists the dependencies of the project, and compatibility constraints (e.g., `SomeDependency = 2.5`).\n",
        "* `Manifest.toml` is an automatically generated file which lists the exact versions and unique IDs (UUIDs) of all the packages that Julia found, based on `Project.toml`. It includes all the implicit dependencies of the project's packages. This is useful to reproduce an environment precisely. Analog to the output of `pip --freeze`.\n",
        "\n",
        "By default, the active project is located in `~/.julia/environments/v#.#` (where `#.#` is the Julia version you are using, such as 1.4). You can set a different project when starting Julia:\n",
        "\n",
        "```bash\n",
        "# BASH\n",
        "julia --project=/path/to/my_project\n",
        "```\n",
        "\n",
        "Or you can set the `JULIA_PROJECT` environment variable:\n",
        "\n",
        "```bash\n",
        "# BASH\n",
        "export JULIA_PROJECT=/path/to/my_project\n",
        "julia\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "84iGO38zM3Cz"
      },
      "source": [
        "Or you can just activate a project directly in Julia (this is analog to running `source my_project/env/bin/activate` when using virtualenv):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tuXofzisM-bW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "11c2b0a9-e9dd-4b8c-f8cc-6a11f07aa46d"
      },
      "source": [
        "Pkg.activate(\"my_project\")"
      ],
      "execution_count": 332,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m  Activating\u001b[22m\u001b[39m new environment at `/content/my_project/Project.toml`\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wOPtEC3UNTsh"
      },
      "source": [
        "The `my_project` directory does not exist yet, but it gets created automatically, along with the `Project.toml` and `Manifest.toml` files, when you first add a package:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yLuWH7U8g84W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0159d462-4712-45e3-d810-ef043f7ef02f"
      },
      "source": [
        "]add PyCall"
      ],
      "execution_count": 333,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/my_project/Project.toml`\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[92m+ PyCall v1.92.2\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/my_project/Manifest.toml`\n",
            " \u001b[90m [8f4d0f93] \u001b[39m\u001b[92m+ Conda v1.5.1\u001b[39m\n",
            " \u001b[90m [682c06a0] \u001b[39m\u001b[92m+ JSON v0.21.1\u001b[39m\n",
            " \u001b[90m [1914dd2f] \u001b[39m\u001b[92m+ MacroTools v0.5.6\u001b[39m\n",
            " \u001b[90m [69de0a69] \u001b[39m\u001b[92m+ Parsers v1.1.0\u001b[39m\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[92m+ PyCall v1.92.2\u001b[39m\n",
            " \u001b[90m [81def892] \u001b[39m\u001b[92m+ VersionParsing v1.2.0\u001b[39m\n",
            " \u001b[90m [2a0f44e3] \u001b[39m\u001b[92m+ Base64\u001b[39m\n",
            " \u001b[90m [ade2ca70] \u001b[39m\u001b[92m+ Dates\u001b[39m\n",
            " \u001b[90m [8f399da3] \u001b[39m\u001b[92m+ Libdl\u001b[39m\n",
            " \u001b[90m [37e2e46d] \u001b[39m\u001b[92m+ LinearAlgebra\u001b[39m\n",
            " \u001b[90m [d6f4376e] \u001b[39m\u001b[92m+ Markdown\u001b[39m\n",
            " \u001b[90m [a63ad114] \u001b[39m\u001b[92m+ Mmap\u001b[39m\n",
            " \u001b[90m [de0858da] \u001b[39m\u001b[92m+ Printf\u001b[39m\n",
            " \u001b[90m [9a3f8284] \u001b[39m\u001b[92m+ Random\u001b[39m\n",
            " \u001b[90m [9e88b42a] \u001b[39m\u001b[92m+ Serialization\u001b[39m\n",
            " \u001b[90m [4ec0a83e] \u001b[39m\u001b[92m+ Unicode\u001b[39m\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KS6OJjVpTcKX"
      },
      "source": [
        "You can also add a package via its URL:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ydZSoyULOlwV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5ae83b6e-e100-44da-c7f0-51d606808878"
      },
      "source": [
        "]add https://github.com/JuliaLang/Example.jl"
      ],
      "execution_count": 334,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaLang/Example.jl`\n",
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/my_project/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[92m+ Example v0.5.4 `https://github.com/JuliaLang/Example.jl#master`\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/my_project/Manifest.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[92m+ Example v0.5.4 `https://github.com/JuliaLang/Example.jl#master`\u001b[39m\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JKr9G4fDGGLv"
      },
      "source": [
        "Let's also add a package with a specific version:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xM8l4uR2GJsM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "05c5d975-99c8-406f-bfed-9c55674cdb7d"
      },
      "source": [
        "]add Example@0.3"
      ],
      "execution_count": 335,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Example ─ v0.3.3\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/my_project/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[93m~ Example v0.5.4 `https://github.com/JuliaLang/Example.jl#master` ⇒ v0.3.3\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/my_project/Manifest.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[93m~ Example v0.5.4 `https://github.com/JuliaLang/Example.jl#master` ⇒ v0.3.3\u001b[39m\n",
            "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
            "\u001b[32m  ✓ \u001b[39mExample\n",
            "1 dependency successfully precompiled in 0 seconds (6 already precompiled)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RCZ-eWicTmVx"
      },
      "source": [
        "Now the `Project.toml` and `Manifest.toml` files were created:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CPbncHi09yFJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8ce6316-eca5-4b2a-f6fc-c2d4d69a0377"
      },
      "source": [
        ";find my_project"
      ],
      "execution_count": 336,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "my_project\n",
            "my_project/Project.toml\n",
            "my_project/Manifest.toml\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jw-VCU41Ua7A"
      },
      "source": [
        "Notice that the packages we added to the project were _not_ placed in the `my_project` directory itself. They were saved in the `~/.julia/packages` directory, the compiled files were placed in `~/.julia/compiled` director, logs were written to `~/.julia/logs` and so on.\n",
        "\n",
        "If several projects use the same package, it will only be downloaded and built once (well, once per version). The `~/.julia/packages` directory can hold multiple versions of the same package, so it's fine if different projects use different versions of the same package. There will be no conflict, no \"dependency hell\".\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o9yjyihUisIK"
      },
      "source": [
        "The `Project.toml` just says that the project depends on `PyCall` and `Example`, and it specifies the UUID of this package:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gz8KscpIhIX4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a5c9b27-f925-4497-fec9-2957c8e48d91"
      },
      "source": [
        "print(read(\"my_project/Project.toml\", String))"
      ],
      "execution_count": 337,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[deps]\n",
            "Example = \"7876af07-990d-54b4-ab0e-23690620f79a\"\n",
            "PyCall = \"438e738f-606a-5dbb-bf0a-cddfbfd45ab0\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IpxulMt32SFf"
      },
      "source": [
        "UUIDs are useful to avoid name conflicts. If several people name their package `CoolStuff`, then the UUID will clarify which one we are referring to."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-_mbX8HUi7Qg"
      },
      "source": [
        "The `Manifest.toml` file is much longer, since it contains all the packages which `PyCall` and `Example` depend on, along with their versions (except for the standard library packages), and the dependency graph. This file should never be modified manually:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "28qXSoSwhOgm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "733d0575-b1b4-40ce-8963-6423f4bd6f31"
      },
      "source": [
        "print(read(\"my_project/Manifest.toml\", String))"
      ],
      "execution_count": 338,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "# This file is machine-generated - editing it directly is not advised\n",
            "\n",
            "[[Base64]]\n",
            "uuid = \"2a0f44e3-6c83-55bd-87e4-b1978d98bd5f\"\n",
            "\n",
            "[[Conda]]\n",
            "deps = [\"JSON\", \"VersionParsing\"]\n",
            "git-tree-sha1 = \"6231e40619c15148bcb80aa19d731e629877d762\"\n",
            "uuid = \"8f4d0f93-b110-5947-807f-2305c1781a2d\"\n",
            "version = \"1.5.1\"\n",
            "\n",
            "[[Dates]]\n",
            "deps = [\"Printf\"]\n",
            "uuid = \"ade2ca70-3891-5945-98fb-dc099432e06a\"\n",
            "\n",
            "[[Example]]\n",
            "git-tree-sha1 = \"276fa06109ac5c80035cff711b0a18ad5b3117cc\"\n",
            "uuid = \"7876af07-990d-54b4-ab0e-23690620f79a\"\n",
            "version = \"0.3.3\"\n",
            "\n",
            "[[JSON]]\n",
            "deps = [\"Dates\", \"Mmap\", \"Parsers\", \"Unicode\"]\n",
            "git-tree-sha1 = \"81690084b6198a2e1da36fcfda16eeca9f9f24e4\"\n",
            "uuid = \"682c06a0-de6a-54ab-a142-c8b1cf79cde6\"\n",
            "version = \"0.21.1\"\n",
            "\n",
            "[[Libdl]]\n",
            "uuid = \"8f399da3-3557-5675-b5ff-fb832c97cbdb\"\n",
            "\n",
            "[[LinearAlgebra]]\n",
            "deps = [\"Libdl\"]\n",
            "uuid = \"37e2e46d-f89d-539d-b4ee-838fcccc9c8e\"\n",
            "\n",
            "[[MacroTools]]\n",
            "deps = [\"Markdown\", \"Random\"]\n",
            "git-tree-sha1 = \"6a8a2a625ab0dea913aba95c11370589e0239ff0\"\n",
            "uuid = \"1914dd2f-81c6-5fcd-8719-6d5c9610ff09\"\n",
            "version = \"0.5.6\"\n",
            "\n",
            "[[Markdown]]\n",
            "deps = [\"Base64\"]\n",
            "uuid = \"d6f4376e-aef5-505a-96c1-9c027394607a\"\n",
            "\n",
            "[[Mmap]]\n",
            "uuid = \"a63ad114-7e13-5084-954f-fe012c677804\"\n",
            "\n",
            "[[Parsers]]\n",
            "deps = [\"Dates\"]\n",
            "git-tree-sha1 = \"c8abc88faa3f7a3950832ac5d6e690881590d6dc\"\n",
            "uuid = \"69de0a69-1ddd-5017-9359-2bf0b02dc9f0\"\n",
            "version = \"1.1.0\"\n",
            "\n",
            "[[Printf]]\n",
            "deps = [\"Unicode\"]\n",
            "uuid = \"de0858da-6303-5e67-8744-51eddeeeb8d7\"\n",
            "\n",
            "[[PyCall]]\n",
            "deps = [\"Conda\", \"Dates\", \"Libdl\", \"LinearAlgebra\", \"MacroTools\", \"Serialization\", \"VersionParsing\"]\n",
            "git-tree-sha1 = \"dd1a970b543bd02efce2984582e996af28cab27f\"\n",
            "uuid = \"438e738f-606a-5dbb-bf0a-cddfbfd45ab0\"\n",
            "version = \"1.92.2\"\n",
            "\n",
            "[[Random]]\n",
            "deps = [\"Serialization\"]\n",
            "uuid = \"9a3f8284-a2c9-5f02-9a11-845980a1fd5c\"\n",
            "\n",
            "[[Serialization]]\n",
            "uuid = \"9e88b42a-f829-5b0c-bbe9-9e923198166b\"\n",
            "\n",
            "[[Unicode]]\n",
            "uuid = \"4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5\"\n",
            "\n",
            "[[VersionParsing]]\n",
            "git-tree-sha1 = \"80229be1f670524750d905f8fc8148e5a8c4537f\"\n",
            "uuid = \"81def892-9a0e-5fdd-b105-ffc91e053289\"\n",
            "version = \"1.2.0\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P1JJXmuz1LPl"
      },
      "source": [
        "Note that `Manifest.toml` contains the precise version of the `Example` package that was installed, but the `Project.toml` file does not specify that version `0.3` is required. That's because Julia cannot know whether your project is supposed to work only with any version `0.3.x`, or whether it could work with other versions as well. So if you want to specify a version constraint for the `Example` package, you must add it manually in `Project.toml`. You would normally use your favorite editor to do this, but in this notebook we'll update `Project.toml` programmatically:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tgddc3M_1iyG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "60ffcd2a-e211-4ed0-ac59-cd6e70a778ad"
      },
      "source": [
        "append_config = \"\"\"\n",
        "\n",
        "[compat]\n",
        "Example = \"0.3\"\n",
        "\"\"\"\n",
        "\n",
        "open(f->write(f, append_config), \"my_project/Project.toml\", \"a\")"
      ],
      "execution_count": 339,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "26"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 339
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BD4rgzAT2GGs"
      },
      "source": [
        "Here is the updated `Project.toml` file:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XNAC8q0H17mI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "afb765c9-8f29-4ce8-add9-c4d70fa302d7"
      },
      "source": [
        "print(read(\"my_project/Project.toml\", String))"
      ],
      "execution_count": 340,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[deps]\n",
            "Example = \"7876af07-990d-54b4-ab0e-23690620f79a\"\n",
            "PyCall = \"438e738f-606a-5dbb-bf0a-cddfbfd45ab0\"\n",
            "\n",
            "[compat]\n",
            "Example = \"0.3\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VyWAJoEq6GZs"
      },
      "source": [
        "Now if we try to replace `Example` 0.3 with version 0.2, we get an error:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qgBa7Y0x6NUm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8ed15bff-39f8-456d-bab7-16024aa5d662"
      },
      "source": [
        "try\n",
        "    pkg\"add Example@0.2\"\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 341,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Pkg.Resolve.ResolverError(\"empty intersection between Example@0.2 and project compatibility 0.3\", nothing)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 341
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R3zvTUWSH4Sa"
      },
      "source": [
        "Now you can run a program based on this project, and it will have the possibility to use all the packages which have been added to this project, with their specific versions. If you import a package which was not explicitly added to this project, Julia will fallback to the default project:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XnSjhJSyISzT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "23904174-872d-4d14-fffd-5e301fb3596e"
      },
      "source": [
        "code = \"\"\"\n",
        "import PyCall # found in the project\n",
        "import PyPlot # not found, so falls back to default project\n",
        "println(\"Success!\")\n",
        "\"\"\"\n",
        "\n",
        "open(f->write(f, code), \"my_program3.jl\", \"w\")"
      ],
      "execution_count": 342,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "117"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 342
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eM4yXtogIc5d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e1a97c01-2b33-4010-b56d-fbf645f9da8b"
      },
      "source": [
        ";julia --project=my_project my_program3.jl"
      ],
      "execution_count": 343,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Success!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U3C_z11CDXzJ"
      },
      "source": [
        "## Packages\n",
        "Falling back to the default project is fine, as long as you run the code on your own machine, but if you want to share your code with other people, it would be brittle to count on packages installed in _their_ default project. Instead, if you plan to share your code, you should clearly specify which packages it depends on, and use only these packages. Such a shareable project is called a **package**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7cLqsDTlMRM9"
      },
      "source": [
        "A package is a regular project (as defined above), but with a few extras:\n",
        "* the `Project.toml` file must specify a `name`, a `version` and a `uuid`.\n",
        "* there must be a `src/PackageName.jl` file containing a module named `PackageName`.\n",
        "* you generally want to specify the `authors` and `description`, and maybe also the `license`, `repository` (e.g., the package's github URL), and some `keywords`, but all of these are optional.\n",
        "\n",
        "It is very easy to create a new package using the `]generate` command. To define the `authors` field, `Pkg` will look up the `user.name` and `user.email` git config entries, so let's define them before we generate the package:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-lrw9Diey5Jw"
      },
      "source": [
        ";git config --global user.name \"Alice Bob\""
      ],
      "execution_count": 344,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jHImoacOzHyR"
      },
      "source": [
        ";git config --global user.email \"alice.bob@example.com\""
      ],
      "execution_count": 345,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bTw_L-4-ls4H",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c863970-4170-4424-e8ee-5164b78f06c5"
      },
      "source": [
        "]generate MyPackages/Hello"
      ],
      "execution_count": 346,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m  Generating\u001b[22m\u001b[39m  project Hello:\n",
            "    MyPackages/Hello/Project.toml\n",
            "    MyPackages/Hello/src/Hello.jl\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_OvnM3tBpW9X"
      },
      "source": [
        "This generated the `MyPackages/Hello/Project.toml` file (along with the enclosing directories) and the `MyPackages/Hello/src/Hello.jl` file. Let's take a look at the `Project.toml` file:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wQqVtTh5qkhm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a10162f6-94ea-49cd-86ca-c11a208323bc"
      },
      "source": [
        "print(read(\"MyPackages/Hello/Project.toml\", String))"
      ],
      "execution_count": 347,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "name = \"Hello\"\n",
            "uuid = \"196c4c10-46f5-4124-abc6-0bad20f5dbfe\"\n",
            "authors = [\"Alice Bob <alice.bob@example.com>\"]\n",
            "version = \"0.1.0\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j1IL7fuyiAtb"
      },
      "source": [
        "Notice that the project has no dependencies yet, but it has a name, a unique UUID, and a version (plus an author)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pgs4xop1qr1z"
      },
      "source": [
        "Note: if `Pkg` does not find a your name or email in the git config, it falls back to environment variables (`GIT_AUTHOR_NAME`, `GIT_COMMITTER_NAME`, `USER`, `USERNAME`, `NAME` and `GIT_AUTHOR_EMAIL`, `GIT_COMMITTER_EMAIL`, `EMAIL`)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VSyvL2-I0S_t"
      },
      "source": [
        "And let's look at the `src/Hello.jl` file:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y4DvJfrC0W_u",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a403babe-46ab-499b-bd41-702d403e9370"
      },
      "source": [
        "print(read(\"MyPackages/Hello/src/Hello.jl\", String))"
      ],
      "execution_count": 348,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "module Hello\n",
            "\n",
            "greet() = print(\"Hello World!\")\n",
            "\n",
            "end # module\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6orcK-WH1dv8"
      },
      "source": [
        "Let's try to use the `greet()` function from the `Hello` package:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ASQUXed1jR9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "db0b4aa0-0efe-4331-c00d-2f6c7d0862c9"
      },
      "source": [
        "try\n",
        "    import Hello\n",
        "    Hello.greet()\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 349,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ArgumentError(\"Package Hello not found in current path:\\n- Run `import Pkg; Pkg.add(\\\"Hello\\\")` to install the Hello package.\\n\")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 349
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ehdlz0d51pRY"
      },
      "source": [
        "Julia could not find the `Hello` package. When you're working on a package, don't forget to activate it first!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "geOkTHsh10es",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b5374610-e15b-413e-bb9e-acee9f68ccde"
      },
      "source": [
        "]activate MyPackages/Hello"
      ],
      "execution_count": 350,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m  Activating\u001b[22m\u001b[39m environment at `/content/MyPackages/Hello/Project.toml`\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aN3bg65b137-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6d50e32b-e9c9-4c8c-fc84-65103ca57475"
      },
      "source": [
        "import Hello\n",
        "Hello.greet()"
      ],
      "execution_count": 351,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "┌ Info: Precompiling Hello [196c4c10-46f5-4124-abc6-0bad20f5dbfe]\n",
            "└ @ Base loading.jl:1317\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Hello World!"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WxXCSYwIE9Eo"
      },
      "source": [
        "It works!\n",
        "\n",
        "If the `Hello` package depends on other packages, we must add them:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cZfLcJO3-m9D",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4a443604-b366-4aae-8888-9b56f2343de0"
      },
      "source": [
        "]add PyCall Example"
      ],
      "execution_count": 352,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Example ─ v0.5.3\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/MyPackages/Hello/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[92m+ Example v0.5.3\u001b[39m\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[92m+ PyCall v1.92.2\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/MyPackages/Hello/Manifest.toml`\n",
            " \u001b[90m [8f4d0f93] \u001b[39m\u001b[92m+ Conda v1.5.1\u001b[39m\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[92m+ Example v0.5.3\u001b[39m\n",
            " \u001b[90m [682c06a0] \u001b[39m\u001b[92m+ JSON v0.21.1\u001b[39m\n",
            " \u001b[90m [1914dd2f] \u001b[39m\u001b[92m+ MacroTools v0.5.6\u001b[39m\n",
            " \u001b[90m [69de0a69] \u001b[39m\u001b[92m+ Parsers v1.1.0\u001b[39m\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[92m+ PyCall v1.92.2\u001b[39m\n",
            " \u001b[90m [81def892] \u001b[39m\u001b[92m+ VersionParsing v1.2.0\u001b[39m\n",
            " \u001b[90m [2a0f44e3] \u001b[39m\u001b[92m+ Base64\u001b[39m\n",
            " \u001b[90m [ade2ca70] \u001b[39m\u001b[92m+ Dates\u001b[39m\n",
            " \u001b[90m [8f399da3] \u001b[39m\u001b[92m+ Libdl\u001b[39m\n",
            " \u001b[90m [37e2e46d] \u001b[39m\u001b[92m+ LinearAlgebra\u001b[39m\n",
            " \u001b[90m [d6f4376e] \u001b[39m\u001b[92m+ Markdown\u001b[39m\n",
            " \u001b[90m [a63ad114] \u001b[39m\u001b[92m+ Mmap\u001b[39m\n",
            " \u001b[90m [de0858da] \u001b[39m\u001b[92m+ Printf\u001b[39m\n",
            " \u001b[90m [9a3f8284] \u001b[39m\u001b[92m+ Random\u001b[39m\n",
            " \u001b[90m [9e88b42a] \u001b[39m\u001b[92m+ Serialization\u001b[39m\n",
            " \u001b[90m [4ec0a83e] \u001b[39m\u001b[92m+ Unicode\u001b[39m\n",
            "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
            "\u001b[32m  ✓ \u001b[39mExample\n",
            "\u001b[32m  ✓ \u001b[39mHello\n",
            "2 dependencies successfully precompiled in 1 seconds (6 already precompiled)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IcipxHQW91lp"
      },
      "source": [
        "You must not use any package which has not been added to the project. If you do, you will get a warning."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9MyUldzLAFZn"
      },
      "source": [
        "Once you are happy with your package, you can deploy it to github (or anywhere else). Then you can add it to your own projects just like any other package.\n",
        "\n",
        "If you want to make your package available to the world via the official Julia registry, you just need to send a Pull Request to https://github.com/JuliaRegistries/General. However, it's highly recommended to automate this using the [Registrator.jl](https://github.com/JuliaRegistries/Registrator.jl) github app.\n",
        "\n",
        "If you want to use other registries (including private registries), check out [this page](https://julialang.github.io/Pkg.jl/v1.4/registries/#)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nNd3-22NIkfB"
      },
      "source": [
        "Also check out the [`PkgTemplate`](https://github.com/invenia/PkgTemplates.jl) package, which provides more sophisticated templates for creating new packages, for example with continuous integration, code coverage tests, etc."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NeVc0WCoJ_yl"
      },
      "source": [
        "## Fixing Issues in a Dependency\n",
        "Sometimes you may run into an issue inside one of the packages your project depends on. When this happens, you can use `Pkg`'s `dev` command to fix the issue. For example, let's pretend the `Example` package has a bug:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HwIRORxQKcxn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a8e1b9e1-ae3e-4b59-aab3-70a0f69dd7b0"
      },
      "source": [
        "]dev Example"
      ],
      "execution_count": 353,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m     Cloning\u001b[22m\u001b[39m git-repo `https://github.com/JuliaLang/Example.jl.git`\n",
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/MyPackages/Hello/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[93m~ Example v0.5.3 ⇒ v0.5.4 `~/.julia/dev/Example`\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/MyPackages/Hello/Manifest.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[93m~ Example v0.5.3 ⇒ v0.5.4 `~/.julia/dev/Example`\u001b[39m\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7e63oY5HKgVD"
      },
      "source": [
        "This command cloned the repo into `~/.julia/dev/Example`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WV77BYAPK-ff",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a3c16f5-3ab6-4d01-fa8b-2308b3781232"
      },
      "source": [
        ";ls -l \"~/.julia/dev\""
      ],
      "execution_count": 354,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "total 4\n",
            "drwxr-xr-x 7 root root 4096 Mar 26 08:50 Example\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pB4nAoM2MmlI"
      },
      "source": [
        "It also updated the `Hello` package's `Manifest.toml` file to ensure the package now uses the `Example` clone. You can see this using `]status`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UldZNewDMYaf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "18561111-5d95-4b81-a081-bc33528823ee"
      },
      "source": [
        "]st"
      ],
      "execution_count": 355,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[36m\u001b[1m     Project\u001b[22m\u001b[39m Hello v0.1.0\n",
            "\u001b[32m\u001b[1m      Status\u001b[22m\u001b[39m `/content/MyPackages/Hello/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[37mExample v0.5.4 `~/.julia/dev/Example`\u001b[39m\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[37mPyCall v1.92.2\u001b[39m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OY080wXKK85W"
      },
      "source": [
        "So you would now go ahead and edit the clone and fix the bug. Of course, you would also want to send a PR to the package's owners so the source package gets fixed. Once that happens, you can go back to the official `Example` package easily:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Ju_ehk6K4fi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "313ca060-dd77-4ace-e892-e1e750935268"
      },
      "source": [
        "]free Example"
      ],
      "execution_count": 356,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/MyPackages/Hello/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[93m~ Example v0.5.4 `~/.julia/dev/Example` ⇒ v0.5.3\u001b[39m\n",
            "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `/content/MyPackages/Hello/Manifest.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[93m~ Example v0.5.4 `~/.julia/dev/Example` ⇒ v0.5.3\u001b[39m\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gZNtvkp0NdQt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f66bc1ca-fcd0-4ce6-c957-8a4bd9267946"
      },
      "source": [
        "]st"
      ],
      "execution_count": 357,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[36m\u001b[1m     Project\u001b[22m\u001b[39m Hello v0.1.0\n",
            "\u001b[32m\u001b[1m      Status\u001b[22m\u001b[39m `/content/MyPackages/Hello/Project.toml`\n",
            " \u001b[90m [7876af07] \u001b[39m\u001b[37mExample v0.5.3\u001b[39m\n",
            " \u001b[90m [438e738f] \u001b[39m\u001b[37mPyCall v1.92.2\u001b[39m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bjk0y4x4X3OC"
      },
      "source": [
        "## Instantiating a Project\n",
        "If you want to run someone else's project and you want to make sure you are using the exact same package versions, you can clone the project, and assuming it has a `Manifest.toml` file, you can activate the project and run `]instantiate` to install all the appropriate packages. For example, let's instantiate the `Registrator.jl` project:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ukq2x0oKYUzv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cd97f389-48d6-4733-d670-63127abd187b"
      },
      "source": [
        ";git clone https://github.com/JuliaRegistries/Registrator.jl"
      ],
      "execution_count": 358,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'Registrator.jl'...\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eP8xWq-lYqIe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c1e7a857-34c2-4a85-ca6c-551ab3ff60f1"
      },
      "source": [
        "]activate Registrator.jl"
      ],
      "execution_count": 359,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m  Activating\u001b[22m\u001b[39m environment at `/content/Registrator.jl/Project.toml`\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mWTuYYjPYtRV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ec9e9153-b4a5-491b-a877-3d672f9d50d6"
      },
      "source": [
        "]instantiate"
      ],
      "execution_count": 360,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m AutoHashEquals ────────────── v0.2.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Hiccup ────────────────────── v0.2.2\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m IniFile ───────────────────── v0.5.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m DataValueInterfaces ───────── v1.0.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m MacroTools ────────────────── v0.5.5\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m AssetRegistry ─────────────── v0.1.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m JLLWrappers ───────────────── v1.1.3\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Pidfile ───────────────────── v1.2.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m DataAPI ───────────────────── v1.3.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Mux ───────────────────────── v0.7.2\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m GitForge ──────────────────── v0.1.6\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m IteratorInterfaceExtensions ─ v1.0.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Parsers ───────────────────── v1.0.7\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m WebSockets ────────────────── v1.5.2\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Mustache ──────────────────── v1.0.3\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m JSON ──────────────────────── v0.21.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m HTTP ──────────────────────── v0.8.16\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m TimeToLive ────────────────── v0.3.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Lazy ──────────────────────── v0.14.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Mocking ───────────────────── v0.7.1\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m TableTraits ───────────────── v1.0.0\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m Tables ────────────────────── v1.0.4\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m ZeroMQ_jll ────────────────── v4.3.2+5\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m JSON2 ─────────────────────── v0.3.2\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m MbedTLS ───────────────────── v1.0.2\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m GitHub ────────────────────── v5.1.6\n",
            "\u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m RegistryTools ─────────────── v1.5.0\n",
            "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mIniFile\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mDataValueInterfaces\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39mTimeToLive\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mParsers\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39mMbedTLS\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mDataAPI\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39mMocking\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mMacroTools\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mPidfile\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mIteratorInterfaceExtensions\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mJLLWrappers\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39mAutoHashEquals\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mJSON2\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39mJSON\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mHiccup\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mTableTraits\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39mHTTP\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mZeroMQ_jll\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39mRegistryTools\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mAssetRegistry\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mTables\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mLazy\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39m\u001b[90mWebSockets\u001b[39m\n",
            "\u001b[32m  ✓ \u001b[39mGitForge\n",
            "\u001b[32m  ✓ \u001b[39mGitHub\n",
            "\u001b[32m  ✓ \u001b[39mMustache\n",
            "\u001b[32m  ✓ \u001b[39mZMQ\n",
            "\u001b[32m  ✓ \u001b[39mMux\n",
            "\u001b[32m  ✓ \u001b[39mRegistrator\n",
            "29 dependencies successfully precompiled in 21 seconds (2 already precompiled)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UoMg99bTtFDp"
      },
      "source": [
        "Usually, that's all you need to know about projects and packages, but let's look at bit under the hood, so you can handle less common cases."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V8Y6A_IuepPI"
      },
      "source": [
        "## Load Path\n",
        "When you import a package, Julia searches for it in the environments listed in the `LOAD_PATH` array. An **environment** can be a project or a directory containing a bunch of packages directly. By default, the `LOAD_PATH` array contains three elements:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wpSWi2epgdpk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5501562c-d591-45c4-9e76-562733a76122"
      },
      "source": [
        "LOAD_PATH"
      ],
      "execution_count": 361,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3-element Vector{String}:\n",
              " \"@\"\n",
              " \"@v#.#\"\n",
              " \"@stdlib\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 361
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hH-S7BL9iuN4"
      },
      "source": [
        "Here's what these elements mean:\n",
        "* `\"@\"` represents the active project, if any: that's the project activated via `--project`, `JULIA_PROJECT`, `]activate` or `Pkg.activate()`.\n",
        "* `\"@v#.#\"` represents the default shared project for the version of Julia we are running. That's why it is used by default when there is no active project.\n",
        "* `\"@stdlib\"` represents the standard library. This is not a project: it's a directory containing many packages."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QHbG_HsOP8O7"
      },
      "source": [
        "If you want to see the actual paths, you can call `Base.load_path()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oGya8XxwQDJz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e8d5e84-a787-494d-994b-d39daf77b7e9"
      },
      "source": [
        "Base.load_path()"
      ],
      "execution_count": 362,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3-element Vector{String}:\n",
              " \"/content/Registrator.jl/Project.toml\"\n",
              " \"/root/.julia/environments/v1.6/Project.toml\"\n",
              " \"/usr/local/share/julia/stdlib/v1.6\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 362
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZaIw9vRxLVVt"
      },
      "source": [
        "You can change the load path if you want to. For example, if you want Julia to look only in the active project and in the standard library, without looking in the default project, then you can set the `JULIA_LOAD_PATH` environment variable to `\"@:@stdlib\"`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8EScSOrdb3ha"
      },
      "source": [
        "If you try to run `my_program3.jl` this way, it will successfully import `PyCall`, but it will fail to import `PyPlot`, since it is not listed in `Project.toml` (however, it would successfully import any package from the standard library):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sN2NunpdLgKR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0663136d-9e40-4209-8287-356bfdf38a02"
      },
      "source": [
        "try\n",
        "    withenv(\"JULIA_LOAD_PATH\"=>\"@:@stdlib\") do\n",
        "        run(`julia --project=my_project my_program3.jl`)\n",
        "    end\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 363,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ERROR: LoadError: ArgumentError: Package PyPlot not found in current path:\n",
            "- Run `import Pkg; Pkg.add(\"PyPlot\")` to install the PyPlot package.\n",
            "\n",
            "Stacktrace:\n",
            " [1] require(into::Module, mod::Symbol)\n",
            "   @ Base ./loading.jl:871\n",
            "in expression starting at /content/my_program3.jl:2\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ProcessFailedException(Base.Process[Process(`\u001b[4mjulia\u001b[24m \u001b[4m--project=my_project\u001b[24m \u001b[4mmy_program3.jl\u001b[24m`, ProcessExited(1))])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 363
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FrLpiVS2UG9S"
      },
      "source": [
        "You can also modify the `LOAD_PATH` array programmatically, for example to make all the packages in the `my_packages/` directory available to the project:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8kGSkqsVULfC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ddff98d2-78cc-4ed9-efa8-5b2ecf6f0ac7"
      },
      "source": [
        "push!(LOAD_PATH, \"my_packages\")"
      ],
      "execution_count": 364,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{String}:\n",
              " \"@\"\n",
              " \"@v#.#\"\n",
              " \"@stdlib\"\n",
              " \"my_packages\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 364
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1_fpeCNoRARJ"
      },
      "source": [
        "Now any package added to this directory will be directly available to us:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3C42rrfKQ01y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a5269fc8-4cee-4b63-d772-519f4ee478f9"
      },
      "source": [
        "]generate my_packages/Hello2"
      ],
      "execution_count": 365,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m  Generating\u001b[22m\u001b[39m  project Hello2:\n",
            "    my_packages/Hello2/Project.toml\n",
            "    my_packages/Hello2/src/Hello2.jl\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ClgC-rhWQ9XP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4c0a3dbb-95bf-4805-9cc5-18aedb3ec28e"
      },
      "source": [
        "using Hello2\n",
        "Hello2.greet()"
      ],
      "execution_count": 366,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "┌ Info: Precompiling Hello2 [7a7171e3-2ca8-45e9-b890-a09bc1065b62]\n",
            "└ @ Base loading.jl:1317\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Hello World!"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-kkX-WKARP0l"
      },
      "source": [
        "This is a convenience for development, as we didn't have to push this package to a repository or even add it to the project. However, it's just for development: once you're happy with your package, make sure to push it to a repo, and add it to the project normally."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C1V5pYziAzWG"
      },
      "source": [
        "## Depots\n",
        "As we saw earlier, new packages you add to a project are placed in the `~/.julia/packages` directory, logs are placed in `~/.julia/logs`, and so on.\n",
        "\n",
        "A directory like `~/.julia` which contains `Pkg` related content is called a **depot**. Julia installs all new packages in the default depot, which is the first directory in the `DEPOT_PATH` array (this array can be modified manually in Julia, or set via the `JULIA_DEPOT_PATH` environment variable):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r4y3Uarp-VXi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "497eb116-0060-4438-fc9f-c7c4ed7a86fd"
      },
      "source": [
        "DEPOT_PATH"
      ],
      "execution_count": 367,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3-element Vector{String}:\n",
              " \"/root/.julia\"\n",
              " \"/usr/local/local/share/julia\"\n",
              " \"/usr/local/share/julia\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 367
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pg_JLf9R-geB"
      },
      "source": [
        "The default depot needs to be writeable for the current user, since that's where new packages will be written to (as well as logs and other stuff). The other depots can be read-only: they're typically used for private package registries."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lAJBZg_RXUqj"
      },
      "source": [
        "You can occasionally run the `]gc` command, which will remove all unused package versions (`Pkg` will use the logs to located existing projects)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1uhHgsN2WUG_"
      },
      "source": [
        "In summary: when some code runs `using Foo` or `import Foo`, the `LOAD_PATH` is used to determine _which_ specific package `Foo` refers to, while the `DEPOT_PATH` is used to determine _where_ it is. The exception is when the `LOAD_PATH` contains directories which directly contain packages: for these packages, the `DEPOT_PATH` is not used."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jgeH4A06IIX4"
      },
      "source": [
        "# Parallel Computing\n",
        "Julia supports coroutines (aka green threads), multithreading (without a [GIL](https://en.wikipedia.org/wiki/Global_interpreter_lock#:~:text=A%20global%20interpreter%20lock%20(GIL,on%20a%20multi%2Dcore%20processor.) like CPython!), multiprocessing and distributed computing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oVCHhzbYFUv5"
      },
      "source": [
        "## Coroutines\n",
        "Let's go back to the `fibonacci()` generator function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LHQ6czbxItEw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "75b0ce57-cd8b-473d-e677-cbd3ba0ece42"
      },
      "source": [
        "function fibonacci(n)\n",
        "    Channel() do ch\n",
        "        a, b = 1, 1\n",
        "        for i in 1:n\n",
        "            put!(ch, a)\n",
        "            a, b = b, a + b\n",
        "        end\n",
        "    end\n",
        "end\n",
        "\n",
        "for f in fibonacci(10)\n",
        "    println(f)\n",
        "end"
      ],
      "execution_count": 368,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n",
            "55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mgDS2AjiVljr"
      },
      "source": [
        "Under the hood, `Channel() do ... end` creates a `Channel` object, and spawns an asynchronous `Task` to execute the code in the `do ... end` block. The task is scheduled to execute immediately, but when it calls the `put!()` function on the channel to yield a value, it blocks until another task calls the `take!()` function to grab that value. You do not see the `take!()` function explicitly in this code example, since it is executed automatically in the `for` loop, in the main task. To demonstrate this, we can just call the `take!()` function 10 times to get all the items from the channel:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-tff7DpqbK-J",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "119fec1b-eaf0-4755-87c3-4990b822e489"
      },
      "source": [
        "ch = fibonacci(10)\n",
        "for i in 1:10\n",
        "    println(take!(ch))\n",
        "end"
      ],
      "execution_count": 369,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n",
            "55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pUZjr1wHdc5y"
      },
      "source": [
        "This channel is bound to the task, therefore it is automatically closed when the task ends. So if we try to get one more element, we will get an exception:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9eJjrbrHdU33",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9377e0f0-0b27-440b-da35-f589287604cf"
      },
      "source": [
        "try\n",
        "    take!(ch)\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 370,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "InvalidStateException(\"Channel is closed.\", :closed)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 370
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VLvvfxZznXps"
      },
      "source": [
        "Here is a more explicit version of the `fibonacci()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FSP1vZjheZDJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89871a44-529d-4003-8ba2-991e6d69b5f5"
      },
      "source": [
        "function fibonacci(n)\n",
        "  function generator_func(ch, n)\n",
        "    a, b = 1, 1\n",
        "    for i in 1:n\n",
        "        put!(ch, a)\n",
        "        a, b = b, a + b\n",
        "    end\n",
        "  end\n",
        "  ch = Channel()\n",
        "  task = @task generator_func(ch, n) # creates a task without starting it\n",
        "  bind(ch, task) # the channel will be closed when the task ends\n",
        "  schedule(task) # start running the task asynchronously\n",
        "  ch\n",
        "end"
      ],
      "execution_count": 371,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "fibonacci (generic function with 1 method)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 371
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-KnzQbUGonIJ"
      },
      "source": [
        "And here is a more explicit version of the `for` loop:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ir3FUJAEoD5j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5fafafb3-88bb-4d5d-eafa-7fe7c524cd49"
      },
      "source": [
        "ch = fibonacci(10)\n",
        "while isopen(ch)\n",
        "  value = take!(ch)\n",
        "  println(value)\n",
        "end"
      ],
      "execution_count": 372,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n",
            "55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YTwMO7gxpCSa"
      },
      "source": [
        "Note that asynchronous tasks (also called \"coroutines\" or \"green threads\") are not actually run in parallel: they cooperate to alternate execution. Some functions, such as `put!()`, `take!()`, and many I/O functions, interrupt the current task's execution, at which point it lets Julia's scheduler decide which task should resume its execution. This is just like Python's coroutines."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yTiiI6ZfbKKQ"
      },
      "source": [
        "For more details on coroutines and tasks, see [the manual](https://docs.julialang.org/en/v1/manual/control-flow/#man-tasks-1)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N9dzuKC2qFRL"
      },
      "source": [
        "## Multithreading\n",
        "Julia also supports multithreading. Currently, you need to specify the number of O.S. threads upon startup, by setting the `JULIA_NUM_THREADS` environment variable (or setting the `-t` argument in Julia 1.5+). In the first cell, we configured the IJulia kernel so that set environment variable is set:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mBYUWpQpDBzS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "64cfefc5-4748-4236-f5c6-48ad06df9367"
      },
      "source": [
        "ENV[\"JULIA_NUM_THREADS\"]"
      ],
      "execution_count": 373,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"4\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 373
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8AK8aRLqEhJt"
      },
      "source": [
        "The actual number of threads started by Julia may be lower than that, as it is limited to the number of available cores on the machine (thanks to hyperthreading, each physical core may run two threads). Here is the number of threads that were actually started:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KjEv4FOwEQhl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e37a6337-4db3-4f9b-c668-90396bb5cef3"
      },
      "source": [
        "using Base.Threads\n",
        "nthreads()"
      ],
      "execution_count": 374,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 374
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tc3bXp57DINZ"
      },
      "source": [
        "Now let's run 10 tasks across these threads:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ic1ecJ-1qatN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9f13497d-65fc-4b84-a565-d2d908b63610"
      },
      "source": [
        "@threads for i in 1:10\n",
        "    println(\"thread #\", threadid(), \" is starting task #$i\")\n",
        "    sleep(rand()) # pretend we're actually working\n",
        "    println(\"thread #\", threadid(), \" is finished\")\n",
        "end"
      ],
      "execution_count": 375,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "thread #3 is starting task #7\n",
            "thread #1 is starting task #1\n",
            "thread #4 is starting task #9\n",
            "thread #2 is starting task #4\n",
            "thread #3 is finished\n",
            "thread #3 is starting task #8\n",
            "thread #2 is finished\n",
            "thread #2 is starting task #5\n",
            "thread #1 is finished\n",
            "thread #1 is starting task #2\n",
            "thread #4 is finished\n",
            "thread #4 is starting task #10\n",
            "thread #3 is finished\n",
            "thread #2 is finished\n",
            "thread #2 is starting task #6\n",
            "thread #4 is finished\n",
            "thread #1 is finished\n",
            "thread #1 is starting task #3\n",
            "thread #1 is finished\n",
            "thread #2 is finished\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SHpLG3h7LVMm"
      },
      "source": [
        "Here is a multithreaded version of the `estimate_pi()` function. Each thread computes part of the sum, and the parts are added at the end:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mDHzyNqdJswG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a30b74b-1503-4802-b41c-453ea2a82c0a"
      },
      "source": [
        "function parallel_estimate_pi(n)\n",
        "    s = zeros(nthreads())\n",
        "    nt = n ÷ nthreads()\n",
        "    @threads for t in 1:nthreads()\n",
        "        for i in (1:nt) .+ nt*(t - 1)\n",
        "          @inbounds s[t] += (isodd(i) ? -1 : 1) / (2i + 1)\n",
        "        end\n",
        "    end\n",
        "    return 4.0 * (1.0 + sum(s))\n",
        "end\n",
        "\n",
        "@btime parallel_estimate_pi(100_000_000)"
      ],
      "execution_count": 376,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  191.037 ms (24 allocations: 2.02 KiB)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.1415926635897367"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 376
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Ql0KLRNSqNg"
      },
      "source": [
        "The `@inbounds` macro is an optimization: it tells the Julia compiler not to add any bounds check when accessing the array. It's safe in this case since the `s` array has one element per thread, and `t` varies from `1` to `nthreads()`, so there is no risk for `s[t]` to be out of bounds."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tVftN7gXQCOh"
      },
      "source": [
        "Let's compare this with the single-threaded implementation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F2Yfz67kK2xX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1dd4bb6e-dad6-4dee-9c6e-f517aaa0a191"
      },
      "source": [
        "@btime estimate_pi(100_000_000)"
      ],
      "execution_count": 377,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  131.668 ms (0 allocations: 0 bytes)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.141592663589326"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 377
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BnOKCxlNQX01"
      },
      "source": [
        "If you are running this notebook on Colab, the parallel implementation is probably no faster than the single-threaded one. That's because the Colab Runtime only has a single CPU, so there is no benefit from multithreading (plus there is a bit of overhead for managing threads). However, on my 8-core machine, using 16 threads, the parallel implementation is about 6 times faster than the single-threaded one."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nOUeRI6DRbmo"
      },
      "source": [
        "Julia has a `mapreduce()` function which makes it easy to implement functions like `parallel_estimate_pi()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c04i5fsvO5m5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dbf34ba3-5970-42ce-a361-0b57e1023e6a"
      },
      "source": [
        "function parallel_estimate_pi2(n)\n",
        "    4.0 * mapreduce(i -> (isodd(i) ? -1 : 1) / (2i + 1), +, 0:n)\n",
        "end"
      ],
      "execution_count": 378,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "parallel_estimate_pi2 (generic function with 1 method)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 378
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZHKduTA-PW5T",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "486b91f4-1e4a-405c-8f68-9fc28fd3b41b"
      },
      "source": [
        "@btime parallel_estimate_pi2(100_000_000)"
      ],
      "execution_count": 379,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  119.696 ms (0 allocations: 0 bytes)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.1415926635897917"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 379
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Lwb_H7vTeCg"
      },
      "source": [
        "The `mapreduce()` function is well optimized, so it's about twice faster than `parallel_estimate_pi()`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g0PXPosbamtW"
      },
      "source": [
        "You can also spawn a task using `Threads.@spawn`. It will get executed on any one of the running threads (it will not start a new thread):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w2YYrw3IYX4v",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "623446f1-682e-4826-eb86-93bac386e3db"
      },
      "source": [
        "task = Threads.@spawn begin\n",
        "    println(\"Thread starting\")\n",
        "    sleep(1)\n",
        "    println(\"Thread stopping\")\n",
        "    42 # result\n",
        "end\n",
        "\n",
        "println(\"Hello!\")\n",
        "\n",
        "println(\"The result is: \", fetch(task))\n"
      ],
      "execution_count": 380,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello!\n",
            "Thread starting\n",
            "Thread stopping\n",
            "The result is: 42\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pbv40Ib7bF7v"
      },
      "source": [
        "The `fetch()` function waits for the thread to finish, and fetches the result. You can also just call `wait()` if you don't need the result."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OsK9bt-Hb2IS"
      },
      "source": [
        "Last but not least, you can use channels to synchronize and communicate across tasks, even if they are running across separate threads:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sgdNzgkaceEz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f3b2a2db-7cab-4004-b638-fee6ca6439c7"
      },
      "source": [
        "ch = Channel()\n",
        "task1 = Threads.@spawn begin\n",
        "    for i in 1:5\n",
        "        sleep(rand())\n",
        "        put!(ch, i^2)\n",
        "    end\n",
        "    println(\"Finished sending!\")\n",
        "    close(ch)\n",
        "end\n",
        "\n",
        "task2 = Threads.@spawn begin\n",
        "    foreach(v->println(\"Received $v\"), ch)\n",
        "    println(\"Finished receiving!\")\n",
        "end\n",
        "\n",
        "wait(task2)"
      ],
      "execution_count": 381,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Received 1\n",
            "Received 4\n",
            "Received 9\n",
            "Received 16\n",
            "Finished sending!\n",
            "Received 25\n",
            "Finished receiving!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eLOdUrTcV1Lh"
      },
      "source": [
        "For more details about multithreading, check out [this page](https://docs.julialang.org/en/v1/manual/parallel-computing/#man-multithreading-1)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0JfyJjTXX1AM"
      },
      "source": [
        "## Multiprocessing & Distributed Programming\n",
        "Julia can spawn multiple Julia processes upon startup if you specify the number of processes via the `-p` argument. You can also spawn extra processes from Julia itself:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JtqG4qIhX5Sw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "125f8f22-b8d0-41c7-dc4d-d681cc3f8035"
      },
      "source": [
        "using Distributed\n",
        "addprocs(4)\n",
        "workers() # array of worker process ids"
      ],
      "execution_count": 382,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4-element Vector{Int64}:\n",
              " 2\n",
              " 3\n",
              " 4\n",
              " 5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 382
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WD9hcmhGfraw"
      },
      "source": [
        "The main process has id 1:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TlsjSMFZe3Ae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1c4e1486-d667-43e0-fda8-7731f7be539e"
      },
      "source": [
        "myid()"
      ],
      "execution_count": 383,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 383
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lAS3Q8ohfvwg"
      },
      "source": [
        "The `@everywhere` macro lets you run any code on all workers:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lmhHLhtbenY5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ad507bb1-e78e-462d-c674-a54409674444"
      },
      "source": [
        "@everywhere println(\"Hi! I'm worker $(myid())\")"
      ],
      "execution_count": 384,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi! I'm worker 1\n",
            "      From worker 5:\tHi! I'm worker 5\n",
            "      From worker 3:\tHi! I'm worker 3\n",
            "      From worker 2:\tHi! I'm worker 2\n",
            "      From worker 4:\tHi! I'm worker 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cyQQ0Td2hAuQ"
      },
      "source": [
        "You can also execute code on a particular worker by using `@spawnat <worker id> <statement>`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mmc1-zfBgsur",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de3f138f-ef52-41de-a45b-31a2fb09f2f6"
      },
      "source": [
        "@spawnat 3 println(\"Hi! I'm worker $(myid())\")"
      ],
      "execution_count": 385,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Future(3, 1, 14, nothing)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 385
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nZaV4ptbk4sB"
      },
      "source": [
        "If you specify `:any` instead of a worker id, Julia chooses the worker for you:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i6C7ydoBkyln",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab888bb6-6d5c-49c4-b3e7-f8b5353dd5c2"
      },
      "source": [
        "@spawnat :any println(\"Hi! I'm worker $(myid())\")"
      ],
      "execution_count": 386,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Future(2, 1, 15, nothing)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 386
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fZMDIATZg9Ug"
      },
      "source": [
        "Both `@everywhere` and `@spawnat` return immediately. The output of `@spawnat` is a `Future` object. You can call `fetch()` on this object to wait for the result:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ml5TBZLQf2oY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c9b842b-e700-472c-f375-c67fb85ec3a6"
      },
      "source": [
        "result = @spawnat 3 1+2+3+4\n",
        "fetch(result)"
      ],
      "execution_count": 387,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "      From worker 3:\tHi! I'm worker 3\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 387
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f8rR6jBdhuvT"
      },
      "source": [
        "If you import some package in the main process, it is <u>not</u> automatically imported in the workers. For example, the following code fails because the worker does not know what `pyimport` is:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s89GQtv5iNfP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80df03a6-d4de-4636-bcc1-1cac598213c3"
      },
      "source": [
        "using PyCall\n",
        "\n",
        "result = @spawnat 4 (np = pyimport(\"numpy\"); np.log(10))\n",
        "\n",
        "try\n",
        "    fetch(result)\n",
        "catch ex\n",
        "    ex\n",
        "end"
      ],
      "execution_count": 388,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "      From worker 2:\tHi! I'm worker 2\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RemoteException(4, CapturedException(UndefVarError(:pyimport), Any[(#119 at macros.jl:87, 1), (#103 at process_messages.jl:274, 1), (run_work_thunk at process_messages.jl:63, 1), (run_work_thunk at process_messages.jl:72, 1), (#96 at task.jl:406, 1)]))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 388
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N-wFnpu7inDg"
      },
      "source": [
        "You must use `@everywhere` or `@spawnat` to import the packages you need in each worker:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eseDsHvzna1R",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d1e1d2c8-fbbf-4703-d3d5-227c01a82873"
      },
      "source": [
        "@everywhere using PyCall\n",
        "\n",
        "result = @spawnat 4 (np = pyimport(\"numpy\"); np.log(10))\n",
        "\n",
        "fetch(result)"
      ],
      "execution_count": 389,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.302585092994046"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 389
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nzk3gbLOnqTx"
      },
      "source": [
        "Similarly, if you define a function in the main process, it is <u>not</u> automatically available in the workers. You must define the function in every worker:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vrvbWhDMnzdX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a33c6b28-b083-4dea-dc49-9d7c0601f1b8"
      },
      "source": [
        "@everywhere addtwo(n) = n + 2\n",
        "result = @spawnat 4 addtwo(40)\n",
        "fetch(result)"
      ],
      "execution_count": 390,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 390
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9skIo6pnoikr"
      },
      "source": [
        "You can pass a `Future` to `@everywhere` or `@spawnat`, as long as you wrap it in a `fetch()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IjovCqk7n_cu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa0808a2-aad6-4ff5-f152-8421c29eeded"
      },
      "source": [
        "M = @spawnat 2 rand(5)\n",
        "result = @spawnat 3 fetch(M) .* 10.0\n",
        "fetch(result)"
      ],
      "execution_count": 391,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5-element Vector{Float64}:\n",
              " 5.871091807490096\n",
              " 0.15951126132338844\n",
              " 8.4716764613543\n",
              " 5.6890356617041355\n",
              " 9.836799648585497"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 391
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H4YeovYto60s"
      },
      "source": [
        "In this example, worker 2 creates a random array, then worker 3 fetches this array and multiplies each element by 10, then the main process fetches the result and displays it."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nUl0Nj9dV-IW"
      },
      "source": [
        "## GPU\n",
        "Julia has excellent GPU support. As you may know, GPUs are devices which can run thousands of threads in parallel. Each thread is slower and more limited than on a CPU, but there are so many of them that plenty of tasks can be executed much faster on a GPU than on a CPU, provided these tasks can be parallelized.\n",
        "\n",
        "Let's check which GPU device is installed:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DTKc9IFB-eum",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25fb764d-7fa5-4763-a454-732f4fafd0b4"
      },
      "source": [
        ";nvidia-smi"
      ],
      "execution_count": 392,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fri Mar 26 08:51:58 2021       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 460.56       Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   41C    P8     9W /  70W |      0MiB / 15109MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ULS7Jn6vws2-"
      },
      "source": [
        "If you're running on Colab, your runtime will generally have an Nvidia Tesla K80 GPU with 12GB of RAM installed, but sometimes other GPUs like Nvidia Tesla T4 16GB, or Nvidia Tesla P100).\n",
        "\n",
        "If no GPU is detected, go to _Runtime_ > _Change runtime type_, set _Hardware accelerator_ to _GPU_, then go to _Runtime_ > _Factory reset runtime_, then reinstall Julia by running the first cell again, then reload the page and come back here). If you're running on your own machine, make sure you have a compatible GPU card installed, with the appropriate drivers."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HzVnsDN--gRr"
      },
      "source": [
        "Now let's create a large matrix and time how long it takes to square it on the CPU:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-rbfON6gWYwe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "51246720-8aca-41eb-e28e-4910945a4c9c"
      },
      "source": [
        "using BenchmarkTools\n",
        "\n",
        "M = rand(2^11, 2^11)\n",
        "\n",
        "function benchmark_matmul_cpu(M)\n",
        "    M * M\n",
        "    return\n",
        "end\n",
        "\n",
        "benchmark_matmul_cpu(M) # warm up\n",
        "@btime benchmark_matmul_cpu($M)"
      ],
      "execution_count": 393,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  418.375 ms (2 allocations: 32.00 MiB)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LRO3dOh1lnVg"
      },
      "source": [
        "Notes:\n",
        "* For benchmarking, we wrapped the operation in a function which returns `nothing`.\n",
        "* Why do we have a \"warm up\" line? Well, since Julia compiles code on the fly the first time it is executed, it's good practice to execute the operation we want to benchmark at least once before starting the benchmark, or else the benchmark will include the compilation time.\n",
        "* We used `$M` instead of `M` on the last line. This is a feature of the `@btime` macro: it evaluates `M` before benchmarking takes place, to avoid the extra delay that is incurred when [benchmarking with global variables](https://docs.julialang.org/en/latest/manual/performance-tips/#Avoid-global-variables-1)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x-nbiuYDtGlb"
      },
      "source": [
        "Now let's benchmark this same operation on the GPU: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3hIWY1O_WE6a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "68f65877-efb5-4b3c-c4b6-cbea8cee2dc7"
      },
      "source": [
        "using CUDA\n",
        "\n",
        "# Copy the data to the GPU. Creates a CuArray:\n",
        "M_on_gpu = cu(M)\n",
        "\n",
        "# Alternatively, create a new random matrix directly on the GPU:\n",
        "#M_on_gpu = CUDA.CURAND.rand(2^11, 2^11)\n",
        "\n",
        "function benchmark_matmul_gpu(M)\n",
        "    CUDA.@sync M * M\n",
        "    return\n",
        "end\n",
        "\n",
        "benchmark_matmul_gpu(M_on_gpu) # warm up\n",
        "@btime benchmark_matmul_gpu($M_on_gpu)"
      ],
      "execution_count": 394,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[32m\u001b[1m Downloading\u001b[22m\u001b[39m artifact: CUDA111\n",
            "\u001b[32m\u001b[1m Downloading\u001b[22m\u001b[39m artifact: CUDNN_CUDA111\n",
            "\u001b[32m\u001b[1m Downloading\u001b[22m\u001b[39m artifact: CUTENSOR_CUDA111\n",
            "ERROR: Data Error : jl_Pe8x6u-download\n",
            "\u001b[32m\u001b[1m Downloading\u001b[22m\u001b[39m artifact: CUTENSOR_CUDA111\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "  2.684 ms (37 allocations: 896 bytes)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jFEBz1hkZ6Ox"
      },
      "source": [
        "That's _much_ faster (185x faster in my test on Colab with an NVidia Tesla P100 GPU)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EbjxRKWc1-nR"
      },
      "source": [
        "Importantly:\n",
        "* Before the GPU can work on some data, it needs to be copied to the GPU (or generated there directly).\n",
        "* the `CUDA.@sync` macro waits for the GPU operation to complete. Without it, the operation would happen in parallel on the GPU, while execution would continue on the CPU. So we would just be timing how long it takes to _start_ the operation, not how long it takes to complete.\n",
        "* In general, you don't need `CUDA.@sync`, since many operations (including `cu()`) call it implicitly, and it's usually a good idea to let the CPU and GPU work in parallel. Typically, the GPU will be working on the current batch of data while the CPU works on preparing the next batch."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lja576nUWXLU"
      },
      "source": [
        "Of course, the speed up will vary depending on the matrix size and the GPU type. Moreover, copying the data from the CPU to the GPU is often the slowest part of the operation, but we only benchmarked the matrix multiplication itself. Let's see what we get if we include the data transfer in the benchmark:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LMegVhMzBtPz"
      },
      "source": [
        "That's still much faster than on the CPU."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WdvtwJAu3aOU"
      },
      "source": [
        "Let's check how much RAM we have left on the GPU:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "599aiP0s3c4y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ceca46a8-5d45-4b39-87d5-07109f45e439"
      },
      "source": [
        "CUDA.memory_status()"
      ],
      "execution_count": 395,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Effective GPU memory usage: 99.98% (14.752 GiB/14.756 GiB)\n",
            "CUDA allocator usage: 14.488 GiB\n",
            "binned usage: 14.488 GiB (20.000 MiB allocated, 14.469 GiB cached)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "86XHVDDrDJjp"
      },
      "source": [
        "Julia's Garbage Collector will free CUDA arrays like any other object, when there's no more reference to it. However, `CUDA.jl` uses a memory pool to make allocations faster on the GPU, so don't be surprised if the allocated memory on the GPU does not go down immediately. Moreover, IJulia keeps a reference to the output of each cell, so if you let any cell output a `CuArray`, it will only be released when you execute `Out[<cell number>]=0`. If you want to force the Garbage Collector to run, you an run `GC.gc()`. To reclaim memory from the memory pool, use `CUDA.reclaim()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VPoO6-h_tVBE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2cb4aacb-6397-4f1a-9645-ad2587151f6d"
      },
      "source": [
        "GC.gc()\n",
        "CUDA.reclaim()"
      ],
      "execution_count": 396,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "15535702016"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 396
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ndcNywPSE0D9"
      },
      "source": [
        "Many other operations are implemented for `CuArray` (`+`,  `-`, etc.) and dotted operations (`.+`, `exp.()`, etc). Importantly, loop fusion also works on the GPU. For example, if we want to compute `M .* M .+ M`, without loop fusion the GPU would first compute `M .* M` and create a temporary array, then it would add `M` to that array, like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "psC2K-M_F0w9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7fd3ea87-ae51-439e-90f2-f99ae3aecda7"
      },
      "source": [
        "function benchmark_without_fusion(M)\n",
        "    P = M .* M\n",
        "    CUDA.@sync P .+ M\n",
        "    return\n",
        "end\n",
        "\n",
        "benchmark_without_fusion(M_on_gpu) # warm up\n",
        "@btime benchmark_without_fusion($M_on_gpu)"
      ],
      "execution_count": 397,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  415.303 μs (59 allocations: 2.00 KiB)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DTbDFRdJIO9M"
      },
      "source": [
        "Instead, loop fusion ensures that the array is only traversed once, without the need for a temporary array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zHQI4nkHGkLx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "309405b9-18d6-4a4c-8c23-279e542072d9"
      },
      "source": [
        "function benchmark_with_fusion(M)\n",
        "    CUDA.@sync M .* M .+ M\n",
        "    return\n",
        "end\n",
        "\n",
        "benchmark_with_fusion(M_on_gpu) # warm up\n",
        "@btime benchmark_with_fusion($M_on_gpu)"
      ],
      "execution_count": 398,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  223.764 μs (64 allocations: 4.03 KiB)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ln5b2NykQCsD"
      },
      "source": [
        "That's _much_ faster (almost twice as fast in my test on Colab). 😃"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9HAHfceIa3U5"
      },
      "source": [
        "Lastly, you can actually **write your own GPU kernels in Julia**! In other words, rather than using GPU operations implemented in the `CUDA.jl` package (or others), you can write Julia code that will be compiled for the GPU, and executed there. This can occasionally be useful to speed up some algorithms where the standard kernels don't suffice. For example, here's a GPU kernel which implements `u .+= v`, where `u` and `v` are two (large) vectors:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lnbRTzgWX0gx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3b1decaa-d578-4be8-dcc7-0c7262697a18"
      },
      "source": [
        "function worker_gpu_add!(u, v)\n",
        "    index = (blockIdx().x - 1) * blockDim().x + threadIdx().x\n",
        "    index ≤ length(u) && (@inbounds u[index] += v[index])\n",
        "    return\n",
        "end\n",
        "\n",
        "function gpu_add!(u, v)\n",
        "    numblocks = ceil(Int, length(u) / 256)\n",
        "    @cuda threads=256 blocks=numblocks worker_gpu_add!(u, v)\n",
        "    return u\n",
        "end"
      ],
      "execution_count": 399,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "gpu_add! (generic function with 1 method)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 399
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WEnX1i4ooQiN"
      },
      "source": [
        "This code example is adapted from the [`CUDA.jl` package's documentation](https://juliagpu.gitlab.io/CUDA.jl/tutorials/introduction/), which I highly encourage you to check out if you're interested in writing your own kernels. Here are the key parts to understand this example, starting from the end:\n",
        "* The `gpu_add!()` function first calculates `numblocks`, the number of blocks of threads to start, then it uses the `@cuda` macro to spawn `numblocks` blocks of GPU threads, each with 256 threads, and each thread runs `worker_gpu_add!(u, v)`.\n",
        "* The `worker_gpu_add!()` function computes `u[index] += v[index]` for a single value of `index`: in other words, each thread will just update a single value in the vector! Let's see how the index is computed:\n",
        "  * The `@cuda` macro spawned many blocks of 256 threads each. These blocks are organized in a grid, which is one-dimensional by default, but it can be up to three-dimensional. Therefore each thread and each block have an `(x, y, z)` coordinate in this grid. See this diagram from the [Nvidia blog post](https://developer.nvidia.com/blog/even-easier-introduction-cuda/):<br />\n",
        "<img src=\"https://juliagpu.gitlab.io/CUDA.jl/tutorials/intro1.png\" width=\"600\"/>.\n",
        "  * `threadIdx().x` returns the current GPU thread's `x` coordinate within its block (one difference with the diagram is that Julia is 1-indexed).\n",
        "  * `blockIdx().x` returns the current block's `x` coordinate in the grid.\n",
        "  * `blockDim().x` returns the block size along the `x` axis (in this example, it's 256).\n",
        "  * `gridDim().x` returns the number of blocks in the grid, along the `x` axis (in this example it's `numblocks`).\n",
        "  * So the `index` that each thread must update in the array is `(blockIdx().x - 1) * blockDim().x + threadIdx().x`.\n",
        "* As explained earlier, the `@inbounds` macro is an optimization that tells Julia that the index is guaranteed to be inbounds, so there's no need for it to check.\n",
        "\n",
        "Now writing your own GPU kernel won't seem like something only top experts with advanced C++ skills can do: you can do it too!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gf6-5tJXRCm0"
      },
      "source": [
        "Let's check that the kernel works as expected:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l7mGsSWYL2iW"
      },
      "source": [
        "u = rand(2^20)\n",
        "v = rand(2^20)\n",
        "\n",
        "u_on_gpu = cu(u)\n",
        "v_on_gpu = cu(v)\n",
        "\n",
        "u .+= v\n",
        "gpu_add!(u_on_gpu, v_on_gpu)\n",
        "\n",
        "@assert Array(u_on_gpu) ≈ u"
      ],
      "execution_count": 400,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GCZyhpbwNeLQ"
      },
      "source": [
        "Yes, it works well!\n",
        "\n",
        "Note: the `≈` operator checks whether the operands are approximately equal within the float precision limit."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Koqs9GrqRHeW"
      },
      "source": [
        "Let's benchmark our custom kernel:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g2_7SawNR4Jb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c50e0a2-d23d-4ba4-9ed2-d8b5f0aec819"
      },
      "source": [
        "function benchmark_custom_assign_add!(u, v)\n",
        "    CUDA.@sync gpu_add!(u, v)\n",
        "    return\n",
        "end\n",
        "\n",
        "benchmark_custom_assign_add!(u_on_gpu, v_on_gpu)\n",
        "@btime benchmark_custom_assign_add!($u_on_gpu, $v_on_gpu)"
      ],
      "execution_count": 401,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  104.583 μs (17 allocations: 384 bytes)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hl0_1Km9SyD7"
      },
      "source": [
        "Let's see how this compares to `CUDA.jl`'s implementation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vogLKdtEO9l6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a7b197b-2a02-46a1-d660-adcf3b40a414"
      },
      "source": [
        "function benchmark_assign_add!(u, v)\n",
        "    CUDA.@sync u .+= v\n",
        "    return\n",
        "end\n",
        "\n",
        "benchmark_assign_add!(u_on_gpu, v_on_gpu)\n",
        "@btime benchmark_assign_add!($u_on_gpu, $v_on_gpu)"
      ],
      "execution_count": 402,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  103.937 μs (22 allocations: 480 bytes)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IKRNLPIRcbCd"
      },
      "source": [
        "How about that? Our custom kernel is just as fast as `CUDA.jl`'s kernel! But to be fair, our kernel would not work with huge vectors, since there's a limit to the number of blocks & threads you can spawn (see [Table 15](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#features-and-technical-specifications) in CUDA's documentation). To support such huge vectors, we need each worker to run a loop like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zi8-UvGocWOK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8ffe3107-5923-452b-bf96-169f746abbef"
      },
      "source": [
        "function worker_gpu_add!(u, v)\n",
        "    index = (blockIdx().x - 1) * blockDim().x + threadIdx().x\n",
        "    stride = blockDim().x * gridDim().x\n",
        "    for i = index:stride:length(u)\n",
        "        @inbounds u[i] += v[i]\n",
        "    end\n",
        "    return\n",
        "end"
      ],
      "execution_count": 403,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "worker_gpu_add! (generic function with 1 method)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 403
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YtQNhlw1c3zo"
      },
      "source": [
        "This way, if `@cuda` is executed with a smaller number of blocks than needed to have one thread per array item, the workers will loop appropriately.\n",
        "\n",
        "This should get you started! For more info, check out [`CUDA.jl`'s documentation](https://juliagpu.gitlab.io/CUDA.jl/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FA9DFoEuiGib"
      },
      "source": [
        "# Command Line Arguments"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I1nlKvCZhVo7"
      },
      "source": [
        "Command line arguments are available via `ARGS`:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ysg_6WElhY7-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37803675-3dc5-490d-c1d7-939508f30ed5"
      },
      "source": [
        "ARGS"
      ],
      "execution_count": 404,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1-element Vector{String}:\n",
              " \"/root/.local/share/jupyter/runtime/kernel-671efb0e-53e0-4b74-873d-456efe1cf676.json\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 404
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jRe_1ovZhdqh"
      },
      "source": [
        "Unlike Python's `sys.argv`, the first element of this array is <u>not</u> the program name. If you need the program name, use `PROGRAM_FILE` instead:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2z3obYZghrHL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "72b97e93-df09-4307-d6cf-cf999ffa61b5"
      },
      "source": [
        "PROGRAM_FILE"
      ],
      "execution_count": 405,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"/root/.julia/packages/IJulia/e8kqU/src/kernel.jl\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 405
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UnKMaPm8r1XC"
      },
      "source": [
        "You can get the current module, directory, file or line number:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZIou0Kgbr5mu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8e17e7e1-85f2-41df-e820-b5d6435560e0"
      },
      "source": [
        "@__MODULE__, @__DIR__, @__FILE__, @__LINE__"
      ],
      "execution_count": 406,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Main, \"/content\", \"In[406]\", 1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 406
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ahpsLiV_hBLi"
      },
      "source": [
        "The equivalent of Python's `if __name__ == \"__main__\"` is:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hPUUlZG6g_A5"
      },
      "source": [
        "if abspath(PROGRAM_FILE) == @__FILE__\n",
        "    println(\"Starting of the program\")\n",
        "end"
      ],
      "execution_count": 407,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8g43x6YYiKLf"
      },
      "source": [
        "# Memory Management"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o-YehjM8iMmn"
      },
      "source": [
        "Let's check how many megabytes of RAM are available:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O80YQtSciPvV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5ba220eb-ace4-4637-f765-bd1a01f7c17e"
      },
      "source": [
        "free() = println(\"Available RAM: \", Sys.free_memory() ÷ 10^6, \" MB\")\n",
        "\n",
        "free()"
      ],
      "execution_count": 408,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Available RAM: 174 MB\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bxKvaTpfdO5j"
      },
      "source": [
        "If a variable holds a large object that you don't need anymore, you can either wait until the variable falls out of scope, or set it to `nothing`. Either way, the memory will only be freed when the Garbage Collector does its magic, which may not be immediate. In general, you don't have to worry about that, but if you want, you can always call the GC directly:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j0M8Oka3fod6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "984db9b5-3525-48c4-c7e5-2b8df17e4c00"
      },
      "source": [
        "function use_ram()\n",
        "    M = rand(10000, 10000) # use 400+MB of RAM\n",
        "    println(\"sum(M)=$(sum(M))\")\n",
        "end # M will be freed by the GC eventually after this\n",
        "\n",
        "use_ram()\n",
        "\n",
        "M = rand(10000, 10000) # use 400+MB of RAM\n",
        "println(\"sum(M)=$(sum(M))\")\n",
        "M = nothing\n",
        "\n",
        "GC.gc() # rarely needed"
      ],
      "execution_count": 409,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "sum(M)=4.999738233440445e7\n",
            "sum(M)=4.9994558021614805e7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O8Fbip9OpRyD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "946a10a0-fa77-4cd7-873a-5e6a6677d41c"
      },
      "source": [
        "free()"
      ],
      "execution_count": 410,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Available RAM: 154 MB\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EsYZBLwwpqEG"
      },
      "source": [
        "# Thanks!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0QOVcDKLptgh"
      },
      "source": [
        "I hope you enjoyed this introduction to Julia! I recommend you join the friendly and helpful Julia community on Slack or Discourse.\n",
        "\n",
        "Cheers!\n",
        "\n",
        "Aurélien Geron"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iC4_Iuyww-gd"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}