MyThinkJulia-Ch19-SyntaxSupplements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch 19: The Goodies: Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Named Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (a=1, b=1+1)\n",
    "x.a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions: compact syntax and anonymous functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(x,y) = x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#3 (generic function with 1 method)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x -> x^2 + 2x - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#5 (generic function with 1 method)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function (x)\n",
    "    x^2 + 2x - 1\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip2200\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip2200)\" points=\"\n",
       "0,1600 2400,1600 2400,0 0,0 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip2201\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polygon clip-path=\"url(#clip2200)\" points=\"\n",
       "229.135,1425.62 2352.76,1425.62 2352.76,47.2441 229.135,47.2441 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip2202\">\n",
       "    <rect x=\"229\" y=\"47\" width=\"2125\" height=\"1379\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  269.223,1425.62 269.223,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  781.592,1425.62 781.592,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1293.96,1425.62 1293.96,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1806.33,1425.62 1806.33,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2318.7,1425.62 2318.7,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  229.135,1377.77 2352.76,1377.77 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  229.135,1099.95 2352.76,1099.95 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  229.135,822.138 2352.76,822.138 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  229.135,544.321 2352.76,544.321 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#000000; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  229.135,266.504 2352.76,266.504 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  229.135,1425.62 2352.76,1425.62 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  229.135,1425.62 229.135,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  269.223,1425.62 269.223,1404.94 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  781.592,1425.62 781.592,1404.94 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1293.96,1425.62 1293.96,1404.94 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1806.33,1425.62 1806.33,1404.94 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2318.7,1425.62 2318.7,1404.94 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  229.135,1377.77 260.99,1377.77 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  229.135,1099.95 260.99,1099.95 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  229.135,822.138 260.99,822.138 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  229.135,544.321 260.99,544.321 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  229.135,266.504 260.99,266.504 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 269.223, 1479.62)\" x=\"269.223\" y=\"1479.62\">0.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 781.592, 1479.62)\" x=\"781.592\" y=\"1479.62\">2.5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1293.96, 1479.62)\" x=\"1293.96\" y=\"1479.62\">5.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 1806.33, 1479.62)\" x=\"1806.33\" y=\"1479.62\">7.5</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:middle;\" transform=\"rotate(0, 2318.7, 1479.62)\" x=\"2318.7\" y=\"1479.62\">10.0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 205.135, 1395.27)\" x=\"205.135\" y=\"1395.27\">0</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 205.135, 1117.45)\" x=\"205.135\" y=\"1117.45\">25</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 205.135, 839.638)\" x=\"205.135\" y=\"839.638\">50</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 205.135, 561.821)\" x=\"205.135\" y=\"561.821\">75</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:end;\" transform=\"rotate(0, 205.135, 284.004)\" x=\"205.135\" y=\"284.004\">100</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:66px; text-anchor:middle;\" transform=\"rotate(0, 1290.95, 1559.48)\" x=\"1290.95\" y=\"1559.48\">x</text>\n",
       "</g>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:66px; text-anchor:middle;\" transform=\"rotate(-90, 89.2861, 736.431)\" x=\"89.2861\" y=\"736.431\">y</text>\n",
       "</g>\n",
       "<polyline clip-path=\"url(#clip2202)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  289.238,1386.61 474.304,1355.52 585.521,1328.12 679.553,1299.84 781.699,1263.83 875.868,1225.73 976.827,1179.68 1093.8,1119.58 1197.75,1060.09 1288.9,1003.22 \n",
       "  1388.29,936.212 1488.26,863.529 1598.8,777.011 1703.97,688.691 1813.32,590.651 1905.37,503.218 2017.76,390.393 2123.4,278.241 2292.65,86.2547 \n",
       "  \"/>\n",
       "<polygon clip-path=\"url(#clip2200)\" points=\"\n",
       "1989.93,251.724 2280.76,251.724 2280.76,130.764 1989.93,130.764 \n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#000000; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1989.93,251.724 2280.76,251.724 2280.76,130.764 1989.93,130.764 1989.93,251.724 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip2200)\" style=\"stroke:#009af9; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2013.93,191.244 2157.93,191.244 \n",
       "  \"/>\n",
       "<g clip-path=\"url(#clip2200)\">\n",
       "<text style=\"fill:#000000; fill-opacity:1; font-family:Arial,Helvetica Neue,Helvetica,sans-serif; font-size:48px; text-anchor:start;\" transform=\"rotate(0, 2181.93, 208.744)\" x=\"2181.93\" y=\"208.744\">y1</text>\n",
       "</g>\n",
       "</svg>\n"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Plots\n",
    "plot(x -> x^2 + 2x - 1, 0, 10, xlabel=\"x\", ylabel=\"y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keyword arguments in a function are specified after a semicolon in the signature but can be called with a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "myplot (generic function with 1 method)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function myplot(x, y; style=\"solid\", width=1, color=\"black\")\n",
    "    ###\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Closures\n",
    "\n",
    "A closure is a technique allowing a function to capture a variable defined outside the calling scope of the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo(x) = ()->x\n",
    "bar = foo(1)\n",
    "bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Blocks\n",
    "\n",
    "A block is a way to group a number of statements. A block starts with the keyword `begin` and ends with `end`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `let` blocks\n",
    "\n",
    "A let block is useful to create new bindings, i.e. locations that can refer to values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1\n",
      "y = -1\n"
     ]
    },
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: z not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: z not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at show.jl:576",
      " [2] top-level scope at In[8]:3"
     ]
    }
   ],
   "source": [
    "x, y, z = -1, -1, -1;\n",
    "let x = 1, z\n",
    "    @show x y z;\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = -1\n",
      "y = -1\n",
      "z = -1\n"
     ]
    }
   ],
   "source": [
    "@show x y z;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example, the first @show macro, shows the local x , the global y and the undefined local z . The global variables are untouched.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### do Blocks\n",
    "\n",
    "In Reading and Writing we had to close the file after when where done writing. This can be done automatically using a do block:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = \"This here's the wattle,\\nthe emblem of our land.\\n\"\n",
    "\n",
    "open(\"testoutput.txt\", \"w\") do fout\n",
    "    write(fout, data)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is functionally equivalent to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f2 = fout -> begin\n",
    "    write(fout, data)\n",
    "end\n",
    "\n",
    "open(f2, \"output.txt\", \"w\")\n",
    "\n",
    "\n",
    "# in Base.open\n",
    "#\n",
    "# function open(f::Function, args...)\n",
    "#     io = open(args...)\n",
    "#     try\n",
    "#         f(io)\n",
    "#     finally\n",
    "#         close(io)\n",
    "#     end\n",
    "# end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A do block can “capture” variables from its enclosing scope. For example, the variable data in the above example of open ... do is captured from the outer scope."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ternary Operator\n",
    "\n",
    "The ternary operator, ?: , is an alternative to an if-elseif statement used when you need to make a choice between single expression values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "even\n"
     ]
    }
   ],
   "source": [
    "a = 150\n",
    "\n",
    "a % 2 == 0 ? println(\"even\") : println(\"odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Short-Circuit Evaluation\n",
    "\n",
    "The operators && and || do a short-circuit evaluation: a next argument is only evaluated when it is needed to determine the final value.\n",
    "\n",
    "For example, a recursive factorial routine could be defined like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fact (generic function with 1 method)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function fact(n::Integer)\n",
    "    n >= 0 || error(\"n must be non-negative\")  # the second statement is called only if the first (n>=0) is false\n",
    "    n == 0 && return 1 # the second statement is called only if the first (n==0) is true.  Same as if n == 0 then return 1 end\n",
    "    n * fact(n-1)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tasks (aka Coroutines)\n",
    "\n",
    "A task is a control structure that can pass cooperatively control without returning. In Julia, a task can be implemented as a function having as first argument a Channel object. A channel is used to pass values from the function to the callee."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fib (generic function with 1 method)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function fib(c::Channel)\n",
    "    \n",
    "    a = 0\n",
    "    b = 1\n",
    "    put!(c, a)\n",
    "    \n",
    "    while true\n",
    "        put!(c, b)\n",
    "        (a, b) = (b, a+b)\n",
    "    end\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`put!` stores values in a channel object and `take!` reads values from it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "fib_gen = Channel(fib);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take!(fib_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take!(fib_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take!(fib_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take!(fib_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take!(fib_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take!(fib_gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The constructor `Channel` creates the task. The function `fib` is suspended after each call to `put`! and resumed after `take!`. For performance reasons, several values of the sequence are buffered in the channel object during a resume/suspend cycle.\n",
    "\n",
    "A channel object can also be used as an iterator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 "
     ]
    }
   ],
   "source": [
    "for val in Channel(fib)\n",
    "    print(val, \" \")\n",
    "    val > 20 && break\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types\n",
    "\n",
    "#### Primitive Types\n",
    "\n",
    "A concrete type consisting of plain old bits is called a primitive type. Unlike most languages, with Julia you can declare your own primitive types. The standard primitive types are defined in the same way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#primitive type Float64 <: AbstractFloat 64 end\n",
    "#primitive type Bool <: Integer 8 end\n",
    "#primitive type Char <: AbstractChar 32 end\n",
    "#primitive type Int64 <: Signed 64 end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number in the statements specifies how many bits are required.\n",
    "\n",
    "The following example creates a primitive type Byte and a constructor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Byte(0x01)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "primitive type Byte 8 end\n",
    "Byte(val::UInt8) = reinterpret(Byte, val)\n",
    "b = Byte(0x01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Parametric Types\n",
    "\n",
    "Julia’s type system is parametric, meaning that types can have parameters.\n",
    "\n",
    "Type parameters are introduced after the name of the type, surrounded by curly braces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Point{T<:Real}\n",
    "    x::T\n",
    "    y::T\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This defines a new parametric type, `Point{T<:Real}`, holding two \"coordinates\" of type `T`, which can be any type having\n",
    "`Real` as supertype."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point{Float64}(0.0, 0.0)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point(0.0, 0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to composite types, abstract types and primitive types can also have a type parameter.\n",
    "    \n",
    "TIP:  Having concrete types for struct fields is absolutely recommended for performance reasons, so this is a good way to make `Point` both fast and flexible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Type Unions\n",
    "\n",
    "A type union is an abstract parametric type that can act as any of its argument types.  A type union is in most computer language an internal construct for reasoning about types. Julia however exposes this feature to its users because efficient code can be generated when the type union has a small number of types. This feature gives the Julia programmer a tremendous flexibility for controlling dispatch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Union{Int64, String}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IntOrString = Union{Int64, String}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "150 :: IntOrString"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Julia\""
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Julia\" :: IntOrString"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods\n",
    "\n",
    "#### Parametric Methods\n",
    "\n",
    "Method definitions can also have type parameters qualifying their signature:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isintpoint(p::Point{T}) where {T} = (T === Int64)\n",
    "\n",
    "p = Point(1, 2)\n",
    "isintpoint(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function-like Objects\n",
    "\n",
    "Any arbitrary Julia object can be made “callable”. Such “callable” objects are sometimes called functors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Polynomial{R}\n",
    "    coeff::Vector{R}\n",
    "end\n",
    "\n",
    "function (p::Polynomial)(x)\n",
    "    val = p.coeff[end]\n",
    "    for coeff in p.coeff[end-1:-1:1]\n",
    "    val = val * x + coeff\n",
    "    end\n",
    "    val\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polynomial{Int64}([1, 10, 100])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Polynomial([1,10,100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "931"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constructors\n",
    "\n",
    "Parametric types can be explicitly or implicitly constructed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point{Int64}(1, 2)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point(1,2) # implicit T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point{Int64}(1, 2)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point{Int64}(1, 2) # explicit T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching Point(::Int64, ::Float64)\nClosest candidates are:\n  Point(::T<:Real, !Matched::T<:Real) where T<:Real at In[5]:2",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching Point(::Int64, ::Float64)\nClosest candidates are:\n  Point(::T<:Real, !Matched::T<:Real) where T<:Real at In[5]:2",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[16]:1"
     ]
    }
   ],
   "source": [
    "Point(1,2.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Default inner and outer constructors are generated for each T:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "struct Point{T<:Real}\n",
    "    x::T\n",
    "    y::T\n",
    "    Point{T}(x,y) where {T<:Real} = new(x,y)\n",
    "end\n",
    "\n",
    "Point(x::T, y::T) where {T<:Real} = Point{T}(x,y);\n",
    "```\n",
    "\n",
    "and both x and y have to be of the same type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When x and y have a different type, the following outer constructor can be defined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "Point(x::Real, y::Real) = Point(promote(x,y)...);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion and Promotion\n",
    "\n",
    "Julia has a system for promoting arguments to a common type. This is not done automatically but can be easily extended. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conversion\n",
    "\n",
    "A value can be converted from one type to another:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 12\n",
    "\n",
    "typeof(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UInt8"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer = convert(UInt8, x)\n",
    "\n",
    "typeof(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add our own convert methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "Base.convert(::Type{Point{T}}, x::Array{T, 1}) where {T<:Real} = Point(x...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point{Int64}(1, 2)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "convert(Point{Int64}, [1, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Promotion\n",
    "\n",
    "Promotion is the conversion of values of mixed types to a single common type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 2.5, 3.0)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "promote(1, 2.5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methods for the promote function are normally not directly defined, but the auxiliary function promote_rule is used to\n",
    "specify the rules for promotion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "promote_rule (generic function with 1 method)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "promote_rule(::Type{Float64}, ::Type{Int32}) = Float64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metaprogramming\n",
    "\n",
    "Julia code can be represented as a data structure of the language itself. This allows a program to transform and generate its own code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Expressions\n",
    "\n",
    "Every Julia program starts as a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Expr"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prog = \"1 + 2\"\n",
    "\n",
    "ex = Meta.parse(prog)\n",
    "typeof(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol call\n",
      "  args: Array{Any}((3,))\n",
      "    1: Symbol +\n",
      "    2: Int64 1\n",
      "    3: Int64 2\n"
     ]
    }
   ],
   "source": [
    "dump(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dump function displays expr objects with annotations.\n",
    "\n",
    "Expressions can be constructed directly by prefixing with : inside parentheses or using a `quote` block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex = quote\n",
    "    1 + 2\n",
    "end;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia can evaluate an expression object using `eval`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every module has its own `eval` function that evaluates expressions in its scope.\n",
    "\n",
    "WARNING\n",
    "\n",
    "When you are using a lot of calls to the function `eval`, often this means that something is wrong. `eval` is considered “evil”."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Macros\n",
    "\n",
    "Macros can include generated code in a program. A macro maps a tuple of Expr objects directly to a compiled expression:\n",
    "\n",
    "Here is a simple macro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@containervariable (macro with 1 method)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "macro containervariable(container, element)\n",
    "    return esc(:($(Symbol(container,element)) = $container[$element]))\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Macros are called by prefixing their name with the @ (at-sign). The macro call @containervariable letters 1 is\n",
    "replaced by:\n",
    "\n",
    "```\n",
    ":(letters1 = letters[1])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(letters1 = letters[1])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@macroexpand @containervariable letters 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example illustrates how a macro can access the name of its arguments, something a function can’t do. The return expression needs to be “escaped” with esc because it has to be resolved in the macro call environment.\n",
    "\n",
    "NOTE: Why macros?\n",
    "\n",
    "Macros are necessary because they execute when code is parsed, therefore, macros allow the programmer to generate and include fragments of customized code before the full program is run. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generated Functions\n",
    "\n",
    "A very special macro is @generated, which allows you to define so-called generated functions. These have the capability to generate specialized code depending on the types of their arguments with more flexibility and/or less code than what can be achieved with multiple dispatch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "square_gen (generic function with 1 method)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@generated function square_gen(x)\n",
    "    Core.println(x)\n",
    "    :(x * x)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The body returns a quoted expression like a macro.\n",
    "\n",
    "For the caller, the generated function behaves as a regular function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Int64\n"
     ]
    }
   ],
   "source": [
    "x = square_gen(2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String\n"
     ]
    }
   ],
   "source": [
    "y = square_gen(\"bar\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"barbar\""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Missing Values\n",
    "\n",
    "Missing values can be represented via the missing object, which is the singleton instance of the type `Missing`. Arrays can contain missing values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Union{Missing, Int64},1}:\n",
       " 1       \n",
       "  missing"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, missing]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The element type of such an array is `Union{Missing, T}`, with `T` the type of the non-missing values.\n",
    "\n",
    "Reduction functions return missing when called on arrays which contain missing values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "missing"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this situation, use the skipmissing` function to skip missing values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(skipmissing([1, missing]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calling C and Fortran Code\n",
    "\n",
    "A lot of code is written in C or Fortran. Reusing tested code is often better than writing your own version of an algorithm.\n",
    "\n",
    "Julia can call directly existing C or Fortran libraries using the ccall syntax.\n",
    "A Julia interface exists for  the GDBM library of database functions. The library is written in C. To close the database a function call to close(db) has to be made:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Base.close(dbm::DBM) = gdbm_close(dbm.handle)\n",
    "function gdbm_close(handle::Ptr{Cvoid})\n",
    "    ccall((:gdbm_close, \"libgdbm\"), Cvoid, (Ptr{Cvoid},), handle)\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dbm object has a field handle of Ptr{Cvoid} type. This field holds a C pointer that refers to the database. \n",
    "\n",
    "To close the database the C function `gdbm_close` has to be called having as only argument the C pointer pointing to the database and no return value. \n",
    "\n",
    "Julia does this directly with the ccall function having as arguments:\n",
    "\n",
    "* a tuple consisting of a symbol holding the name of the function we want to call: `:gdbm_close` and the shared library specified as a string: `\"libgdm\"`,\n",
    "* the return type: `Cvoid`,\n",
    "* a tuple of argument types: (Ptr{Cvoid},) and the argument values: `handle`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.4.0",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}