Week1_6-TypeSystem.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\n",
       "\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: #ddd;\n",
       "    color: #000000;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Philosopher', sans-serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 2.2em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(0, 80, 120);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 1.9em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(200,100,0);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    margin-top:12px;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: italic;\n",
       "    color: rgb(94,127,192);\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {\n",
       "    font-family: 'Alegreya Sans', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 16pt;\n",
       "    color: grey;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 {\n",
       "    font-family: 'PT Mono', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 10pt;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: \"PT Mono\";\n",
       "        font-size: 100%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "\n"
      ],
      "text/plain": [
       "HTML{ASCIIString}(\"<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\\n\\n<style>\\n\\n@font-face {\\n    font-family: \\\"Computer Modern\\\";\\n    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\\n}\\n\\n#notebook_panel { /* main background */\\n    background: #ddd;\\n    color: #000000;\\n}\\n\\n\\n\\n/* Formatting for header cells */\\n.text_cell_render h1 {\\n    font-family: 'Philosopher', sans-serif;\\n    font-weight: 400;\\n    font-size: 2.2em;\\n    line-height: 100%;\\n    color: rgb(0, 80, 120);\\n    margin-bottom: 0.1em;\\n    margin-top: 0.1em;\\n    display: block;\\n}\\t\\n.text_cell_render h2 {\\n    font-family: 'Philosopher', serif;\\n    font-weight: 400;\\n    font-size: 1.9em;\\n    line-height: 100%;\\n    color: rgb(200,100,0);\\n    margin-bottom: 0.1em;\\n    margin-top: 0.1em;\\n    display: block;\\n}\\t\\n\\n.text_cell_render h3 {\\n    font-family: 'Philosopher', serif;\\n    margin-top:12px;\\n    margin-bottom: 3px;\\n    font-style: italic;\\n    color: rgb(94,127,192);\\n}\\n\\n.text_cell_render h4 {\\n    font-family: 'Philosopher', serif;\\n}\\n\\n.text_cell_render h5 {\\n    font-family: 'Alegreya Sans', sans-serif;\\n    font-weight: 300;\\n    font-size: 16pt;\\n    color: grey;\\n    font-style: italic;\\n    margin-bottom: .1em;\\n    margin-top: 0.1em;\\n    display: block;\\n}\\n\\n.text_cell_render h6 {\\n    font-family: 'PT Mono', sans-serif;\\n    font-weight: 300;\\n    font-size: 10pt;\\n    color: grey;\\n    margin-bottom: 1px;\\n    margin-top: 1px;\\n}\\n\\n.CodeMirror{\\n        font-family: \\\"PT Mono\\\";\\n        font-size: 100%;\\n}\\n\\n</style>\\n\\n\")"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Setting up a custom stylesheet in IJulia\n",
    "file = open(\"style.css\") # A .css file in the same folder as this notebook file\n",
    "styl = readall(file) # Read the file\n",
    "HTML(\"$styl\") # Output as HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Julia's type system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>In this lecture</h2>\n",
    "\n",
    "- [Outcome](#Outcome)\n",
    "\n",
    "- [A word of reassurance](#A-word-of-reassurance)\n",
    "- [Types are formats for storing information](#Types-are-formats-for-storing-information)\n",
    "- [Stored information must also store its type](#Stored-information-must-also-store-its-type)\n",
    "- [In Julia, only values have types](#In-Julia,-only-values-have-types)\n",
    "- [The types Char, ASCIIString and UTF8String](#The-types-Char,-ASCIIString-and-UTF8String)\n",
    "- [The type Bool](#The-type-Bool)\n",
    "- [The types Int64 and Float64](#The-types-Int64-and-Float64)\n",
    "- [Concrete and abstract types](#Concrete-and-abstract-types)\n",
    "- [Julia has a tree of types](#Julia-has-a-tree-of-types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<h2>Outcome</h2>\n",
    "\n",
    "After this lecture, you will be able to: \n",
    "\n",
    "- Say what types are from the point of view of computer languages\n",
    "- Use the typeof() function to determine the type of a value\n",
    "- Describe Julia's tree of types in terms of abstract and concrete types\n",
    "- Describe the types Char, ASCIIString and UTF8String \n",
    "- Describe the types Int64 and Float64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>A word of reassurance</h2>\n",
    "\n",
    "## YOU CAN ALMOST ALWAYS IGNORE TYPES WHEN YOU WRITE JULIA CODE\n",
    "\n",
    "One of the nicest things about Julia is that, while its type system is totally amazing, you can ignore it if you like. People often do---you write code as rapidly as you can, to see whether an idea could possibly work. Then if you like what you see, but the code runs slowly, you tweak it. And in Julia, this means you work on getting the types right.\n",
    "\n",
    "There is one case however where type cannot be ignored: when you get an error message that complains about type. That is, for purposes of debugging it is essential to know about Julia's type system, and that is why we include it this early in the course, even though you need never specify type in any of the assignments in this course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Types are formats for storing information</h2>\n",
    "\n",
    "We all know that information is stored and moved around in computers using zeros and ones. \n",
    "\n",
    "That means stuff like 00011100011000110111011011111010101101\n",
    "\n",
    "But how do we tell if this lot represents a number, or several numbers, or a colour, or a word, or what?\n",
    "\n",
    "This is where formats come in. If you knew what format to use, you could tell what that sequence of zeros and ones meant.\n",
    "\n",
    "Each computer language has its own way of specifying the formats of information that it can use. Those are its types. Julia also has a type system, which is quite elaborate.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Stored information must also store its type</h2>\n",
    "\n",
    "This is obvious---without knowing the type, its just a bunch of meaningless zeros and ones!\n",
    "\n",
    "But the question is: *where* do you store the type for a given piece of information? Different languages do this in different ways. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>In Julia, only values have types</h2>\n",
    "\n",
    "We have so far seen Julia do things like the following:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+3+5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each of \"1\", \"3\" and \"5\" are symbols that stand for values, and so does the \"9\" that is the result of the calculation.\n",
    "\n",
    "In Julia, each of those values have a type. And values are the only things that have types in Julia. Of course, there is a lot of careful detail in how to make sure that the zeros and ones that specify the value remain connected with the zeros and ones that specify the type. In C, for instance, the programmmer must think about this all the time. Luckily in Julia we need not worry, those details are taken care of.\n",
    "\n",
    "It is easy to determine a type in Julia, by using the built-in function typeof():\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(1+3+5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ASCIIString"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(\"Hello, world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UTF8String"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(\"αβγδ\")     # Greek letters via Unicode, easy in Julia  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ASCIIString"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(\"H\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Char"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof('H')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(1+3+5.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Julia is very sensitive to type: every single bit of work is done in terms of types.\n",
    "\n",
    "You need not worry about types at all, if you don't want to: Julia will automatically assign types to any values you create. \n",
    "\n",
    "On the other hand, it is possible to specify in great detail what types you want. You can even extend Julia's type system with your own user-defined types. This can be a great help in speeding up code (although in this course we do not go into that)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>The types Char, ASCIIString and UTF8String</h2>\n",
    "\n",
    "As we have seen, a string is a sequence of characters. For languages using the Roman letters, all the necessary characters are on a standard keyboard, so you just type them in. These are also the only alphabetic characters in the original ASCII list, which specifies exactly 128 characters.\n",
    "\n",
    "Other characters are available via Unicode, as we have already seen. You type \"\\\" followed by some more characters, followed by pressing Tab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: syntax: incomplete: premature end of input\nwhile loading In[2], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: syntax: incomplete: premature end of input\nwhile loading In[2], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "α ± ♢ ♣       # examples of entering Unicode characters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All of these characters of course have a value in the Julia language, so they have a type, namely Char.\n",
    "\n",
    "In Julia, types are given names that start with capital letters.\n",
    "\n",
    "Now here's the thing. Suppose you have lots of strings, but some of them use only ASCII while others use some Unicode characters that are not part of ASCII. To work with ASCII-only strings can be much faster, because ASCII has only a few characters, while Unicode has thousands. For example, if you want to test whether they're the same, you need only check the ASCII characters. But if you had to first read the whole string to decide whether it was pure ASCII or not, you'd be doing a lot of extra work and you would lose the advantages of speed.\n",
    "\n",
    "So the designers of Julia decided that it was worth having more types of string: we've seen ASCIIString for strings supposed to have only ASCII characters and UTF8String for string that have Unicode characters from the whole UTF8 specification in Unicode. There are other string types as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>The type Bool</h2>\n",
    "\n",
    "Bool here is short for Boolean, which is named for George Boole, who suggested that all of logic could be presented in terms of the values \"true\" and \"false\". He invented an algebra for doing logical calculations using these values.\n",
    "\n",
    "This is an extremely simple type. In the computer, it occupies only eight bits, and it is limited to only two possible values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "typeof(true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<h2>The types Int64 and Float64</h2>\n",
    "\n",
    "Of course, all scientific and technical computation depends on handling numbers very efficiently. Julia has a great many number types, but by far the two most important are Int64 for representing integers and Float64 for representing real numbers. To be precise, Float64 is a floating point format for real numbers.\n",
    "\n",
    "Both of them use 64 bits to represent the number. However, the way they interpret these bits is quite different, even if the values are the same.\n",
    "\n",
    "When we type them out, the difference is very simple: \n",
    "\n",
    "- an integer has no fractional part, so we type them without a decimal point. \n",
    "- for a floating point number, we always put in the decimal point, even if the fractional part is zero\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(2.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This explains why \"1+3+5.\" above has the type Float64, not Int64, which may have surprised you.\n",
    "\n",
    "Julia compares values correctly, even if the types differ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.0 == 2     # true, although the types differ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 3/2      # false. Note that although both 3 and 2 are integers, 3/2 is not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a strict comparison operator, namely \"===\" which is true only if two values agree fully as to type as well as value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.0 ===  2    # false. The values are equal but the types differ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<h2>Concrete and abstract types</h2>\n",
    "\n",
    "All the types above are concrete types. That is, they have no subtypes.\n",
    "\n",
    "But it is very useful to group types together. For example, both Int64 and Float64 are numbers, and one can do things with numbers without knowing exactly which type of number you are dealing with. For this purpose, Julia defines a supertype for every type (except the type Any). For example, Float64 has the supertype Real \n",
    "\n",
    "This can get complicated: Int64 has the supertype Signed, which has the supertype Integer, which has the supertype Real.\n",
    "\n",
    "Note that the type Real includes both Int64 and Float64. Types like Real and Integer, which can have subtypes, are called abstract types. The most abstract type of all is the type Any.\n",
    "\n",
    "Now. The actual type of a value in Julia must always be a concrete type. So where do abstract types come in? There are two answers:\n",
    "- some operations change the type of a value; abstract types help to guide this process\n",
    "- functions are written to operate on types. If you write your function to use an abstract type, it will work for all the types underneath that abstract type.\n",
    "\n",
    "As was noted above, you can write your Julia code without any type specifications at all. What happens is that Julia then uses abstract types to specify your code. Most of them time, this is absolutely fine. But it can seriously hamper speed, so if your aim is to write programs that run fast, you will need to learn how to use type specifications. As this course is for beginners, we do not cover that topic.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<h2>Julia has a tree of types</h2>\n",
    "\n",
    "This means that the most abstract type of all, namely the type Any, splits into subtypes that do not overlap, and this is again true for further splits into subtypes.\n",
    "\n",
    "A different way of saying this is that every type has exactly one direct supertype.\n",
    "\n",
    "What this means is that there can be no confusion about how types are related in Julia: you can trace any two types back to their lowest common supertype. This certainty is a very important aspect of the Julia type system."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.4.5",
   "language": "julia",
   "name": "julia-0.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.4.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}