Scala Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Table Of Contents\n",
    "\n",
    "* [Basics: variables, constants, imports](#basics-vars-consts-imports)\n",
    "* [Classes and OOP](#classes-oop)\n",
    "* [Types](#types)\n",
    "* [Implicit Conversions](#implicit_conversions)\n",
    "* [Functional Values/Closures](#functional_values_closures)\n",
    "* [Traits](#traits)\n",
    "* [Standard Scala Collections](#standard_scala_collections)\n",
    "* [Pattern Matching and Regex](#pattern_matching_and_regex)\n",
    "* [Exception Handling](#exception_handling)\n",
    "* [Lazy Evaluation and Streams/Generators](#lazy_evaluation_streams_generators)\n",
    "* [Parallel Collections](#parallel_collections)\n",
    "* [Miscellaneous](#miscellaneous)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='basics-vars-consts-imports'/>\n",
    "# Basics: variables, constants, imports"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables & Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[36mx\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m6\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Mutable variables are defined with var\n",
    "var x = 5;\n",
    "x = 6\n",
    "println(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mx\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m5\u001b[0m\n",
       "\u001b[36my\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m6\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Val means immutable/final - i.e. final int x = 5; in Java\n",
    "val x = 5\n",
    "val y : Int = 6 // With type\n",
    "// x = 6 Would give a compilation error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1-2-3"
     ]
    },
    {
     "data": {
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// For-each\n",
    "for (i <- List(1,2,3)) {\n",
    "    print(s\"-$i\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123\n",
      "12"
     ]
    },
    {
     "data": {
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// To is inclusive, until is exclusive!\n",
    "// 'To' and 'until' are methods!\n",
    "for (i <- 1 to 3) {\n",
    "    print(i)\n",
    "}\n",
    "println()\n",
    "for (i <- 1 until 3) {\n",
    "    print(i)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[36mx\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m1\u001b[0m\n",
       "\u001b[36my\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m2\u001b[0m\n",
       "\u001b[36mtpl\u001b[0m: (\u001b[32mInt\u001b[0m, \u001b[32mInt\u001b[0m) = \u001b[33m\u001b[0m(\u001b[32m1\u001b[0m, \u001b[32m2\u001b[0m)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Tuples ... They are 1-based, not zero-based!\n",
    "val (x,y) = (1,2)\n",
    "val tpl = (1,2)\n",
    "println(tpl._1) // Prints 1\n",
    "println(tpl._2) // Prints 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Varargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1--2--3--4-\n",
      "-1--2--3--4-"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Vararg\n",
    "def f(ints :Int*){\n",
    "    for (i <- ints) {print(s\"-$i-\")}\n",
    "}\n",
    "f(1,2,3,4)\n",
    "println(\"\")\n",
    "f(Array(1,2,3,4):_*) // Array explode - i.e. convert array to vararg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default and named args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Default Values\n",
    "def f(x: Int = 5) = print(x)\n",
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(x,y)"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Named args\n",
    "def f (x:String,y:String) = print(x,y)\n",
    "f(y=\"y\", x=\"x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implicit Args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x and Implicit y\n",
      "x and Explicit y\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m\n",
       "\u001b[36my\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"Implicit y\"\u001b[0m\n",
       "\u001b[36my_num\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m5\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f(x: String)(implicit y:String) = println (s\"$x and $y\")\n",
    "\n",
    "implicit var y = \"Implicit y\" // Will be implicitly passed for the y param\n",
    "//implicit var yy = \"Implicit YY\" - Would give compilation error\n",
    "implicit var y_num = 5 // OK since the type is different\n",
    "\n",
    "f(\"x\")\n",
    "f(\"x\")(\"Explicit y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36ms\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"single line\"\u001b[0m\n",
       "\u001b[36mraw_s\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"\"\"\n",
       "Multiline with \"quotes\"\n",
       "            text\n",
       "\"\"\"\u001b[0m\n",
       "\u001b[36mraw_s_regex\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"\"\"\n",
       "\\s+\n",
       "\"\"\"\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "val s = \"single line\"\n",
    "val raw_s = \"\"\"Multiline with \"quotes\"\n",
    "            text\"\"\"\n",
    "val raw_s_regex = \"\"\"\\s+\"\"\" // No need to escape in raw strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Interpolation and Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36minterpol\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"S=single line\"\u001b[0m\n",
       "\u001b[36mi\u001b[0m: \u001b[32mDouble\u001b[0m = \u001b[32m10.1234\u001b[0m\n",
       "\u001b[36mprice\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"$10.1234 dollars\"\u001b[0m\n",
       "\u001b[36mf_price\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"10.12 dollars\"\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Interpolation\n",
    "val interpol = s\"S=$s\" // Works for raw strings as well\n",
    "val i = 10.1234\n",
    "val price = s\"$$$i dollars\" // Gotta escape that $ sign\n",
    "\n",
    "// Formatting Interpolation\n",
    "val f_price = f\"${i}%2.2f dollars\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison - Operator ==, eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "false\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[36ms1\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"s\"\u001b[0m\n",
       "\u001b[36ms2\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"s\"\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// In Scala == always defers to equals (unlike in Java!)\n",
    "val s1 = new String(\"s\")\n",
    "val s2 = new String(\"s\")\n",
    "println(s1 == s2) // Prints true\n",
    "\n",
    "// To compare by reference - use the new eq method\n",
    "println(s1 eq s2) // Prints false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32mimport \u001b[36mscala.collection.immutable\u001b[0m\n",
       "\u001b[32mimport \u001b[36mscala.collection.immutable._\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Same as java\n",
    "import scala.collection.immutable\n",
    "\n",
    "// _ is the new *\n",
    "import scala.collection.immutable._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='classes-oop'/>\n",
    "# Classes and OOP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Access Control - public/private/protected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mC\u001b[0m\n",
       "\u001b[36mc\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mC\u001b[0m = cmd13$$user$C@45cbc155"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// By default everything is public..\n",
    "class C {\n",
    "    def m1 = println(\"m1\")\n",
    "    private def m2 = println(\"m2\") // Can only access from this instance!\n",
    "    protected def m3 = println(\"m3\") // Can only access from this instance!\n",
    "}\n",
    "val c = new C\n",
    "c.m1\n",
    "//c.m2 // Wouldn't compile\n",
    "//c.m3 // Same here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining Classes & OOP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point(1, 2, 3) with color: RED\n",
      "Point(1, 3, 3) with color: RED\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mPoint3D\u001b[0m\n",
       "\u001b[36mp\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mPoint3D\u001b[0m = cmd14$$user$Point3D@191a8f44"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// In Scala we create constructors, not classes!\n",
    "class Point3D(val x:Int, var y:Int, z:Int) {   // Primary Constructor ... will be called as: new Point(5,6)\n",
    "    private var color = \"RED\" // Another member variable ... not initialised in the ctor\n",
    "    def method() = s\"Point($x, $y, $z) with color: $color\"\n",
    "}\n",
    "val p = new Point3D(1,2,3)\n",
    "println(p.method)\n",
    "// p.x = 6 - compilation error as x is a val\n",
    "p.y = 3 // y can be assigned, as it is a var\n",
    "println(p.method)\n",
    "//println(p.z) - compilation error as z is not a val or var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mPoint2D\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Without a body\n",
    "// Will automatically add a getter for X, and a getter and a setter for Y\n",
    "class Point2D(val x: Int, var y:Int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Secondary Constructors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point(1, 5), null\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mPoint2DDefault\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// To define a secondary ctor - use \"this\"\n",
    "class Point2DDefault(val x:Int, val y:Int) {\n",
    "    var defaultValue : String = _ // Default - null for objects, 0 for numbers\n",
    "    def this(x:Int){\n",
    "        this(x, 5) // Call the primary constructor\n",
    "    }\n",
    "    override def toString() = s\"Point($x, $y), $defaultValue\"\n",
    "}\n",
    "println(new Point2DDefault(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type aliases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mPointy\u001b[0m\n",
       "defined \u001b[32mtype \u001b[36mPt\u001b[0m\n",
       "\u001b[36mres17_2\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mPointy\u001b[0m = cmd17$$user$Pointy@7bab8332"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Pointy(val x:Int, val y:Int)\n",
    "type Pt = Pointy // Alias it\n",
    "new Pt(1,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mBase\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mDer\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Base(val x: Int)\n",
    "\n",
    "// Only the primary ctor can call the super\n",
    "// X must have \"override\", as it overrides the base's value\n",
    "class Der(override val x: Int, val y : Int) extends Base(x) { \n",
    "    def this() {\n",
    "        this(0,0)\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameterised Types/Generics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 of type class java.lang.Integer\n",
      "String of type class java.lang.String\n",
      "String of type class java.lang.String\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f[T](t:T) = println(s\"$t of type ${t.getClass}\")\n",
    "\n",
    "f(1)\n",
    "f(\"String\")\n",
    "f[String](\"String\") // Explicitly specify the type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mBox\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Box[T](var el:T){\n",
    "    override def toString = s\"$el\"\n",
    "}\n",
    "println(new Box(123))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Singletons, Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f(5)\n",
      "List(1, 2, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mobject \u001b[36mSomeSingleton\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Creates a singleton class and object\n",
    "object SomeSingleton { // No sonstructors!\n",
    "    val value = List(1,2,3)\n",
    "    def f(p:Any) = s\"f($p)\"\n",
    "}\n",
    "println(SomeSingleton.f(5))\n",
    "println(SomeSingleton.value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Companion Objects/Singletons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = 123\n",
      "X = 789\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mSomEntity\u001b[0m\n",
       "defined \u001b[32mobject \u001b[36mSomEntity\u001b[0m\n",
       "\u001b[36mentity\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mSomEntity\u001b[0m = X = 789"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// If a class and an object/singleton share the same name - they are \"connected\" (i.e. companion)\n",
    "class SomEntity private(){// Private constructor\n",
    "    // Will be accessible from the object\n",
    "    private var x = 123\n",
    "    override def toString = s\"X = $x\"\n",
    "}\n",
    "// Accompanying object - same name as the class\n",
    "object SomEntity{\n",
    "    def create = new SomEntity //Calls a privte ctor\n",
    "    def setX(x:Int, entity: SomEntity) = entity.x = x // modifies a private variable\n",
    "}\n",
    "var entity = SomEntity.create\n",
    "println(entity)\n",
    "SomEntity.setX(789, entity)\n",
    "println(entity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enumerations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NORTH\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mobject \u001b[36mDirection\u001b[0m\n",
       "\u001b[36md\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mDirection\u001b[0m.\u001b[32mValue\u001b[0m = NORTH"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Enums are objects extending Enumeration\n",
    "object Direction extends Enumeration {\n",
    "    val NORTH, EAST, SOUTH, WEST = Value\n",
    "}\n",
    "//var d:Direction = null - Would not compile, as Direction is an object, not a class!!\n",
    "println(Direction.NORTH)\n",
    "// The enum type comes from Direction.Value ...\n",
    "var d: Direction.Value = Direction.NORTH "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mobject \u001b[36mDirection2\u001b[0m\n",
       "defined \u001b[32mtype \u001b[36mDirection2\u001b[0m\n",
       "\u001b[36md\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mDirection2\u001b[0m = NORTH"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// To define the enumeration as a type (not just an object):\n",
    "object Direction2 extends Enumeration {\n",
    "    val NORTH, EAST, SOUTH, WEST = Value\n",
    "}\n",
    "// Need to alias the type\n",
    "type Direction2 = Direction2.Value\n",
    "\n",
    "// Unlike the previous example ... the following compiles\n",
    "var d:Direction2 = Direction2.NORTH"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Package Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "// Can't test packages in the notebook :-("
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='types'/>\n",
    "# Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nothing and Any"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "java.lang.IllegalStateException"
     ]
    }
   ],
   "source": [
    "// \"scala.Nothing\" (a.k.a. bottom type) is a subtype of all types! It can never be instantiated.\n",
    "// Used only as a return type of methods that always fail!\n",
    "def fail() : Nothing = throw new IllegalStateException()\n",
    "\n",
    "// We can assign Nothing to everything, as it is a bottom - everyone's subtype!\n",
    "var x: Int = fail()\n",
    "var y: Double = fail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mx\u001b[0m: \u001b[32mAny\u001b[0m = 6.123"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// \"scala.Any\" is the universal supertype - it's a supertype of all types\n",
    "var x: Any = null\n",
    "x = 5\n",
    "x = 6.123"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AnyVal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Sybtypes Any;\n",
    "* Is a base type for all value types - Java calls them primitive ... they are not garbage collected;\n",
    "* Does not have any methods;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mx\u001b[0m: \u001b[32mAnyVal\u001b[0m = 12.3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "var x: AnyVal = 3;\n",
    "x = 12.3\n",
    "//x = \"STRING\" - this wouldn't compile, as String is not value/primitive;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AnyRef"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Sybtypes Anyl\n",
    "* Is a base type for all reference types - i.e. similar to java.lang.Object\n",
    "* Has some of Object's methods - norfy, wait, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mx\u001b[0m: \u001b[32mAnyRef\u001b[0m = STRING"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "var x: AnyRef = null; // We can assign null to it\n",
    "x = \"STRING\"\n",
    "//x = 5 - this wouldn't compile as 5 is of a value/primitive type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* like void in Java;\n",
    "* Extends AnyVal;\n",
    "* Has only one possible value - ();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Unit is like void in java\n",
    "var u : Unit = ()\n",
    "// var u = null - wouldn't compile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Option"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something\n",
      "Empty\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[36mopt1\u001b[0m: \u001b[32mOption\u001b[0m[\u001b[32mString\u001b[0m] = Some(Something)\n",
       "\u001b[36mopt2\u001b[0m: \u001b[32mOption\u001b[0m[\u001b[32mString\u001b[0m] = None"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Option is a wrapper/box of a value. It may or may not contain a value\n",
    "val opt1 : Option[String] = Some(\"Something\") // a new Option[String] with a filling/content\n",
    "val opt2 : Option[String] = None              // an empty one - holds nothing\n",
    "\n",
    "println (opt1.get)\n",
    "println (opt2.getOrElse(\"Empty\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Either"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36msuccess\u001b[0m: \u001b[32mRight\u001b[0m[\u001b[32mNothing\u001b[0m, \u001b[32mInt\u001b[0m] = \u001b[33mRight\u001b[0m(\u001b[32m3\u001b[0m)\n",
       "\u001b[36mer\u001b[0m: \u001b[32mLeft\u001b[0m[\u001b[32mString\u001b[0m, \u001b[32mNothing\u001b[0m] = \u001b[33mLeft\u001b[0m(\u001b[32m\"BAD ERROR\"\u001b[0m)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Either is like Option, but it can also contain an error message or code\n",
    "// Right means success, Left means failure\n",
    "val success = Right (1 + 2)\n",
    "val er = Left(\"BAD ERROR\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Generics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mlstInt\u001b[0m: \u001b[32mjava\u001b[0m.\u001b[32mutil\u001b[0m.\u001b[32mArrayList\u001b[0m[\u001b[32mInt\u001b[0m] = []\n",
       "\u001b[36mlstNothing1\u001b[0m: \u001b[32mjava\u001b[0m.\u001b[32mutil\u001b[0m.\u001b[32mArrayList\u001b[0m[\u001b[32mNothing\u001b[0m] = []\n",
       "\u001b[36mlstNothing2\u001b[0m: \u001b[32mjava\u001b[0m.\u001b[32mutil\u001b[0m.\u001b[32mArrayList\u001b[0m[\u001b[32mNothing\u001b[0m] = []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "var lstInt = new java.util.ArrayList[Int]\n",
    "\n",
    "// \"Nothing\" is a subtype of all types! \n",
    "var lstNothing1 = new java.util.ArrayList\n",
    "// same as lstNothing1\n",
    "var lstNothing2 = new java.util.ArrayList[Nothing] \n",
    "// lstInt = lstNothing2 - won't compile as the types are in fact different!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Covariance and Contravariane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "Compilation Failed",
      "\u001b[31mMain.scala:284: type mismatch;",
      " found   : java.util.ArrayList[Int]",
      " required: java.util.ArrayList[Any]",
      "Note: Int <: Any, but Java-defined class ArrayList is invariant in type E.",
      "You may wish to investigate a wildcard type such as `_ <: Any`. (SLS 3.2.10)",
      "arr1 = arr2",
      "       ^\u001b[0m"
     ]
    }
   ],
   "source": [
    "// The problem: The following does not compile\n",
    "var arr1 : java.util.ArrayList[Any] = null\n",
    "var arr2 : java.util.ArrayList[Int] = null\n",
    "arr1 = arr2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** _Note:_ ** - Assuming we have a container class **Box[T]**, and two types **Base** and **Der**, such that **Der** is a subtype of **Base**. Then:\n",
    "* ** Covariance ** - if we can assign a **Box[Der]** value to a **Box[Base]** reference.\n",
    "* ** Contravariance ** - if we can assign a **Box[Base]** value to a **Box[Der]** reference.\n",
    "\n",
    "By default Scala does no allow co and contra-variance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32mimport \u001b[36mjava.util.ArrayList\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mBase\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mDer\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Common classes for the examples:\n",
    "import java.util.ArrayList\n",
    "class Base(){ override def toString = \"Base\" }\n",
    "class Der extends Base(){ override def toString = \"Der\" }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contra/Covariant Containers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mBox\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mCoBox\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mContraBox\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// We need to define the container itself as co-/contravariant\n",
    "class Box[T] (){}; // just a box\n",
    "class CoBox[+T] (); // Covariant\n",
    "class ContraBox[-T] (); // Contravariant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mbaseCoBox\u001b[0m: \u001b[32mCoBox\u001b[0m[\u001b[32mBase\u001b[0m] = null\n",
       "\u001b[36mderCoBox\u001b[0m: \u001b[32mCoBox\u001b[0m[\u001b[32mDer\u001b[0m] = null\n",
       "\u001b[36mbaseContraBox\u001b[0m: \u001b[32mContraBox\u001b[0m[\u001b[32mBase\u001b[0m] = null\n",
       "\u001b[36mderContraBox\u001b[0m: \u001b[32mContraBox\u001b[0m[\u001b[32mDer\u001b[0m] = null"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "var baseCoBox : CoBox[Base] = null;\n",
    "var derCoBox : CoBox[Der] = null\n",
    "baseCoBox = derCoBox // Works because of co-variance\n",
    "//derCoBox = baseCoBox - does not compile as it is not cotravariant\n",
    "\n",
    "var baseContraBox : ContraBox[Base] = null;\n",
    "var derContraBox : ContraBox[Der] = null\n",
    "derContraBox = baseContraBox // Works because of contra-variance\n",
    "//baseContraBox = derContraBox - does not compile as it is not contra-variant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contra/Covariant Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Called method\n",
      "Called method\n",
      "Called method\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36msimpleF\u001b[0m\n",
       "defined \u001b[32mfunction \u001b[36mcovF\u001b[0m\n",
       "\u001b[36mdb\u001b[0m: \u001b[32mBox\u001b[0m[\u001b[32mDer\u001b[0m] = null\n",
       "\u001b[36mbb\u001b[0m: \u001b[32mBox\u001b[0m[\u001b[32mBase\u001b[0m] = null"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// A mthod without co/contra variance - can not give it Box[Der] values\n",
    "def simpleF(b : Box[Base]) : Unit = { println(\"Called method\") }\n",
    "\n",
    "// Covariant method\n",
    "def covF[T <: Base] (b : Box[T]) : Unit = { println(\"Called method\") }\n",
    "\n",
    "var db : Box[Der] = null\n",
    "var bb : Box[Base] = null\n",
    "covF(bb)\n",
    "covF(db)\n",
    "simpleF(bb)\n",
    "//simpleF(db)  - wouldn't work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Value Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like structs in C# and Java primitives. They don't live on the heap and are not garbage collected. Destroyed when the current scope closes. Case classes and implicit classes are always value classes.\n",
    "\n",
    "Value classes in Scala:\n",
    "* Extend AnyVal\n",
    "* Can not be inherited\n",
    "* Can not define own vars and vals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "// This notebook does not support value classes :(\n",
    "// If it did, it would be something like:\n",
    "// class ValueClass(val x : Int) extends AnyVal {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='implicit_conversions'/>\n",
    "# Implicit Conversions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implicit methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Used to defined DSL. Require that a certain library is imported - _\"import​ scala.language.implicitConversions\"_. \n",
    "\n",
    "Basically allows you to inject logic into how the compiler matched methods to implementations.\n",
    "\n",
    "// **TODO** give some examples ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implicit classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to implicit methods. Will not cover here for now ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='functional_values_closures'/>\n",
    "# Functional Values/Closures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mtype \u001b[36mFType\u001b[0m\n",
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m\n",
       "\u001b[36mg\u001b[0m: (\u001b[32mString\u001b[0m, \u001b[32mInt\u001b[0m) => \u001b[32mString\u001b[0m = <function2>\n",
       "\u001b[36mres37_3\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"a1\"\u001b[0m\n",
       "\u001b[36mres37_4\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"a1\"\u001b[0m\n",
       "\u001b[36mres37_5\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"a1\"\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Function types are defined like that:\n",
    "type FType = (String, Int) => String // Use type aliasing\n",
    "\n",
    "def f(s:String, n:Int) = s + n // f is of the specified type\n",
    "val g : FType = (s,n) => s + n // g is also of that type. Here we used a lambda expression\n",
    "\n",
    "// Invocations\n",
    "f(\"a\", 1)\n",
    "g(\"a\", 1)\n",
    "//f.apply(\"a\", 1) - wouldn't compile :(\n",
    "g.apply(\"a\", 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Currying"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Currying** means partial applications. If you're calling a function with \"similar\" params again and again, you can create an intermediate/partial application of the function with the common params. Then you can call that partially applied function to the distinct params only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m\n",
       "\u001b[36mres38_1\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m6\u001b[0m\n",
       "\u001b[36mf12\u001b[0m: \u001b[32mInt\u001b[0m => \u001b[32mInt\u001b[0m = <function1>\n",
       "\u001b[36mres38_3\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m6\u001b[0m\n",
       "\u001b[36mres38_4\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m7\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// A curried function - just use multiple param lists:\n",
    "def f (a : Int) (b : Int) (c: Int) = a + b + c\n",
    "\n",
    "// Just call it ...\n",
    "f(1)(2)(3)\n",
    "\n",
    "// Partially applied function - NOTE the '_' at the end of the invoation!\n",
    "val f12 = f(1)(2)_\n",
    "\n",
    "f12(3)\n",
    "f12(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Partial function application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m\n",
       "\u001b[36mf1\u001b[0m: \u001b[32mInt\u001b[0m => \u001b[32mInt\u001b[0m = <function1>\n",
       "\u001b[36mres39_2\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m2\u001b[0m\n",
       "\u001b[36mres39_3\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m3\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f(x:Int, y:Int) = x + y\n",
    "\n",
    "// Define a partially applied function - use the _ for the lefover parameter\n",
    "val f1 = f(1, _ :Int)\n",
    "\n",
    "f1(1)\n",
    "f1(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Positional Args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mres94_0\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m6\u001b[0m\n",
       "\u001b[36mres94_1\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m6\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Positional - declare and apply the arg \"in-place\"\n",
    "List(1,2,3).foldLeft(0)(_ + _)\n",
    "\n",
    "// Same as\n",
    "List(1,2,3).foldLeft(0)( (x,y) => x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Param Routing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m\n",
       "defined \u001b[32mfunction \u001b[36mf2\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// We can take the entire param list and pass it over to another function\n",
    "def f(x:Int, y:Int) = Math.max _\n",
    "\n",
    "// Same as\n",
    "def f2(x:Int, y:Int) = Math.max(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='traits'/>\n",
    "# Traits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traits and Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mtrait \u001b[36mBaseT\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Traits do not have constructors\n",
    "trait BaseT {\n",
    "    // Defines a value, which will appear in all subtypes, because it is initialised\n",
    "    val fromBase : String = \"FromBase\"\n",
    "    // Unitialised - thus the derived classes must define it! I.e. it is abstract\n",
    "    val fromDer : String\n",
    "    // Unitialised - thus the derived classes must define it! I.e. it is abstract\n",
    "    def abstractMessage\n",
    "    // Use the abstract and non-abstract values and definitions\n",
    "    def message = println(s\"Values $fromBase $fromDer $abstractMessage\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FromBase\n",
      "Derived\n",
      "Derived class implementation\n",
      "Derived class implementation\n",
      "Values FromBase Derived ()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mDerC\u001b[0m\n",
       "\u001b[36mx\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mDerC\u001b[0m = cmd43$$user$DerC@7b7ab743"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Define the abstract val and def\n",
    "class DerC(override val fromDer:String) extends BaseT {\n",
    "    override def abstractMessage = println(\"Derived class implementation\")\n",
    "}\n",
    "val x = new DerC(\"Derived\")\n",
    "println(x.fromBase)\n",
    "println(x.fromDer)\n",
    "x.abstractMessage\n",
    "x.message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mtrait \u001b[36mBaseT1\u001b[0m\n",
       "defined \u001b[32mtrait \u001b[36mBaseT2\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mMultiTrait\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mInheritWithMultiTrait\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// You can also use multiple traits\n",
    "trait BaseT1 {}\n",
    "trait BaseT2 {}\n",
    "\n",
    "// Use with to add more traits\n",
    "class MultiTrait extends BaseT1 with BaseT2 \n",
    "class InheritWithMultiTrait extends AnyRef with BaseT1 with BaseT2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traits and objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mSomeClass\u001b[0m\n",
       "\u001b[36mxWithBaseT\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mSomeClass\u001b[0m with \u001b[32mBaseT\u001b[0m = cmd45$$user$$anonfun$2$$anon$1@25bf39b5\n",
       "\u001b[36mx\u001b[0m: \u001b[32mBaseT\u001b[0m = cmd45$$user$$anonfun$2$$anon$1@25bf39b5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Does not extend BaseT, but \"implements\" its abstract members\n",
    "class SomeClass(val fromDer:String){\n",
    "    def abstractMessage = println(\"Derived class implementation\")\n",
    "}\n",
    "\n",
    "// Apply the BaseT trait for an instance only!\n",
    "val xWithBaseT = new SomeClass(\"Test\") with BaseT\n",
    "var x : BaseT = xWithBaseT // Now we can assign"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='standard_scala_collections'/>\n",
    "# Standard Scala Collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutable vs Immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scala has 3 main types of collections - List, Set, and Map. They be either mutable or immutable, depending on which of the following packages they are loaded from:\n",
    "* scala.collection.mutable\n",
    "* scala.collection.immutable\n",
    "\n",
    "By default the immutable collections are used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Construction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36ml\u001b[0m: \u001b[32mList\u001b[0m[\u001b[32mInt\u001b[0m] = \u001b[33mList\u001b[0m(\u001b[32m1\u001b[0m, \u001b[32m2\u001b[0m, \u001b[32m3\u001b[0m)\n",
       "\u001b[36ms\u001b[0m: \u001b[32mSet\u001b[0m[\u001b[32mInt\u001b[0m] = \u001b[33mSet\u001b[0m(\u001b[32m1\u001b[0m, \u001b[32m2\u001b[0m, \u001b[32m3\u001b[0m)\n",
       "\u001b[36mm\u001b[0m: \u001b[32mMap\u001b[0m[\u001b[32mInt\u001b[0m, \u001b[32mString\u001b[0m] = \u001b[33mMap\u001b[0m(\u001b[32m1\u001b[0m -> \u001b[32m\"1\"\u001b[0m, \u001b[32m2\u001b[0m -> \u001b[32m\"2\"\u001b[0m)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// We don't need to explicitly call a constructor (i.e. new) to create them\n",
    "// they define a special factory method called \"apply\" allowing for this magic\n",
    "val l = List(1,2,3)\n",
    "var s = Set(1,2,3)\n",
    "var m = Map(1 -> \"1\", 2 -> \"2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set(1, 2, 3, 4)\n",
      "Set(1)\n",
      "Set(2, 3)\n",
      "Set(2)\n",
      "List(1, 2, 1, 3, 4)\n",
      "List(1, 2, 1, 3, 4)\n",
      "1\n",
      "1\n",
      "List(1, 2, 3, 4)\n",
      "List(1, 2, 3)\n",
      "List()\n",
      "1\n",
      "List(2, 3)\n",
      "1\n",
      "1\n",
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Set ops\n",
    "println(Set(1,2) ++ Set(1,3,4)) // Gives back Set(1, 2, 3, 4)\n",
    "println(Set(1,2) & Set(1,3,4)) // Gives back Set(1)\n",
    "println(Set(1,2).map(_ + 1)) // Gives back Set(2,3)\n",
    "println(Set(1,2).filter(_ % 2 == 0)) // Gives back Set(2)\n",
    "\n",
    "// List ops\n",
    "println(List(1,2) ++ List(1,3,4)) // Gives back List(1, 2, 1, 3, 4)\n",
    "println(List(1,2) ::: List(1,3,4)) // Same as above. Gives back List(1, 2, 1, 3, 4)\n",
    "// Map and filter work as expected\n",
    "println(List(1,2).apply(0)) // 1\n",
    "println(List(1,2)(0)) // 1; Same as apply\n",
    "println(1 :: List(2,3,4)) // Appends in front; Gives back List(1, 2, 3, 4)\n",
    "println(1::2::3::Nil) // Another way to construct a list\n",
    "println(Nil) // Nill is a special value for an empty list of all types\n",
    "println(List(1,2,3).head) // Gets the first element 1\n",
    "println(List(1,2,3).tail) // Gets the first element List(2,3)\n",
    "\n",
    "// Map ops\n",
    "println(Map(1 -> \"1\").apply(1)) // Access though apply\n",
    "println(Map(1 -> \"1\")(1)) // Access though (index) rather than [index]. Same as apply\n",
    "println(Map(1 -> \"1\").get(1).get) // gets an Option, and then its value \"1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Folding lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mlist\u001b[0m: \u001b[32mList\u001b[0m[\u001b[32mInt\u001b[0m] = \u001b[33mList\u001b[0m(\u001b[32m1\u001b[0m, \u001b[32m2\u001b[0m, \u001b[32m3\u001b[0m, \u001b[32m4\u001b[0m)\n",
       "\u001b[36mres48_1\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m10\u001b[0m\n",
       "\u001b[36mres48_2\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m10\u001b[0m\n",
       "\u001b[36mres48_3\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m10\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "val list = List(1,2,3,4)\n",
    "list.foldLeft(0) (_ + _)\n",
    "(0 /: list) (_ + _) // Syntactic sugar for the same. Cryptic?\n",
    "\n",
    "// Ulike fold, reduce does not take a starting value\n",
    "list.reduceLeft(_ + _)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scala has some syntactic sugar for looping over and transforming collections:\n",
    "```scala\n",
    "for(x1 <- generator1;\n",
    "    ...\n",
    "    xn <- generatorN(x1, ... ,xn-1);\n",
    "    if condition(x1, ... , xn)\n",
    ") yield expression(x1, ... , xn);\n",
    "```\n",
    "\n",
    "This will collect all yielded values into a list.\n",
    "\n",
    "It is similar to list comprehensions in python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mres\u001b[0m: \u001b[32mList\u001b[0m[(\u001b[32mInt\u001b[0m, \u001b[32mInt\u001b[0m)] = \u001b[33mList\u001b[0m(\u001b[33m\u001b[0m(\u001b[32m1\u001b[0m, \u001b[32m1\u001b[0m), \u001b[33m\u001b[0m(\u001b[32m2\u001b[0m, \u001b[32m2\u001b[0m))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Will return List((1,1), (2,2))\n",
    "val res = for(i <- List(1,2,3);\n",
    "               j <- List(i);\n",
    "               if i + j < 5\n",
    "            ) yield (i,j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='pattern_matching_and_regex'/>\n",
    "# Pattern Matching and Regex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Text, Primitives, Regex, Tuples, Lists etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's Saturday\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m\n",
       "\u001b[36mres50_1\u001b[0m: \u001b[32mAny\u001b[0m = ()\n",
       "\u001b[36mres50_2\u001b[0m: \u001b[32mAny\u001b[0m = Don't know which it is"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Strings\n",
    "def f(s:String) = \n",
    "    s match {\n",
    "        case \"Saturday\" => println(\"It's Saturday\")\n",
    "        case \"Sunday\" => println(\"Sunday hoooray!\")\n",
    "        case _ => \"Don't know which it is\"\n",
    "    }\n",
    "f(\"Saturday\")\n",
    "f(\"Monday\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m\n",
       "\u001b[36mres51_1\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"Tuple starting with 5\"\u001b[0m\n",
       "\u001b[36mres51_2\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"Any tuple - in this case (2 3)\"\u001b[0m\n",
       "\u001b[36mres51_3\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"A list starting with 5\"\u001b[0m\n",
       "\u001b[36mres51_4\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"A list starting with 1 and 2\"\u001b[0m\n",
       "\u001b[36mres51_5\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"An int 5\"\u001b[0m\n",
       "\u001b[36mres51_6\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"Not sure what is happening!\"\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Tuples, lists, others\n",
    "def f(x:Any) : String = {\n",
    "    x match {\n",
    "        case (5, _) => \"Tuple starting with 5\"\n",
    "        case (a, b) => s\"Any tuple - in this case ($a $b)\"\n",
    "        case 5::_ => \"A list starting with 5\"\n",
    "        case List(1, 2, _*) => \"A list starting with 1 and 2\"\n",
    "        case a : Int => s\"An int $a\"\n",
    "        case _ => \"Not sure what is happening!\"\n",
    "    }\n",
    "}\n",
    "\n",
    "f((5, 1))\n",
    "f((2, 3))\n",
    "f(List(5, 6, 7))\n",
    "f(List(1, 2, 3))\n",
    "f(5)\n",
    "f(12.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m\n",
       "\u001b[36mres52_1\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"Is Positive\"\u001b[0m\n",
       "\u001b[36mres52_2\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"Is not positive\"\u001b[0m\n",
       "\u001b[36mres52_3\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"Something about me\"\u001b[0m\n",
       "\u001b[36mres52_4\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"Something about me\"\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "//Matching with preconditions\n",
    "def f(x : Any):String = {\n",
    "    x match {\n",
    "        case i:Int if (i >= 0) => \"Is Positive\"\n",
    "        case i:Int if (i < 0) => \"Is not positive\"\n",
    "        case s:String if(s contains \"me\") => \"Something about me\"\n",
    "        case _ => \"Not sure\"\n",
    "    }\n",
    "}\n",
    "f(1)\n",
    "f(-5)\n",
    "f(\"About me\")\n",
    "f(\"Something happening over here\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Case classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:Shh!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mXFile\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mYFile\u001b[0m\n",
       "\u001b[36mx\u001b[0m: \u001b[32mAny\u001b[0m = XFile(Secret)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Case classes have a single constructor and cannot have other member vars\n",
    "case class XFile(file: String);\n",
    "case class YFile(file: String);\n",
    "\n",
    "// We don't need to say \"new\" when creating objects\n",
    "val x:Any = XFile(\"Secret\")\n",
    "\n",
    "// Now we can pattern match on it:\n",
    "x match {\n",
    "    case XFile(\"Secret\") => println(\"X:Shh!\")\n",
    "    case YFile(\"Secret\") => println(\"Y:Shh!\")\n",
    "    case XFile(_) => println(\"What did X say?\")\n",
    "    case YFile(_) => println(\"What did Y say?\")\n",
    "    case _ => println(\"Say What?\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nothing\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mtrait \u001b[36mMyOption\u001b[0m\n",
       "defined \u001b[32mobject \u001b[36mMyNothing\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mMySomething\u001b[0m\n",
       "\u001b[36mx\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mMyOption\u001b[0m[\u001b[32mString\u001b[0m] = MyNothing"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Case classes are often combined with sealed traids\n",
    "// A sealed trait can only be inherited from its own file - i.e. external libraries and modules can't\n",
    "sealed trait MyOption[+A]\n",
    "case object MyNothing extends MyOption[Nothing]\n",
    "case class MySomething[A](val v : A) extends MyOption[A]\n",
    "\n",
    "val x: MyOption[String] = MyNothing\n",
    "x match {\n",
    "    case MyNothing => println(\"Nothing\")\n",
    "    case MySomething(v) => println(v)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extractors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extractors are **objects** which have a special method calle **unapply**. It takes a value and \"breaks it up\"\n",
    "into composite parts. Often extractors also have an **apply** method, which builds a value out of composite\n",
    "parts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1@2\n",
      "1 AT 2\n",
      "1@2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mobject \u001b[36mEmailExtractor\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "object EmailExtractor {\n",
    "    def unapply(s : String):Option[Array[String]] = {\n",
    "        val parts = s.split(\"@\")\n",
    "        if(parts.length == 2) Some(parts) else None\n",
    "    }\n",
    "    def apply(l : Array[String]) = l.mkString(\"@\")\n",
    "}\n",
    "println(EmailExtractor.apply(Array(\"1\", \"2\")))\n",
    "println(EmailExtractor.unapply(\"1@2\").get.mkString(\" AT \"))\n",
    "\n",
    "// Will call apply!\n",
    "println(EmailExtractor(Array(\"1\", \"2\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case statements, Scala provides some syntax sugar for calling the unapply method. However, you must ensure that unapply's result has a method called **isEmpty**, which the match-case mechanism will use\n",
    "to determine if the match is successful. **Option** has such a method and is most often used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matched Option 2. Email is: user AT email.com\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[36mx\u001b[0m: \u001b[32mString\u001b[0m = \u001b[32m\"user@email.com\"\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "val x = \"user@email.com\"\n",
    "\n",
    "x match {\n",
    "    // i.e. if it matches object EmailExtractor.unapply(\"1@2\")\n",
    "    //case Array(\"1\",\"2\") => println(\"Array\")\n",
    "    case EmailExtractor(Array(\"1\",\"2\")) => println(\"Matched Option 1. Email is 1@2\")\n",
    "    // i.e. if it matches EmailExtractor.unapply matches the pattern\n",
    "    case EmailExtractor(Array(u, d)) => println(s\"Matched Option 2. Email is: $u AT $d\")\n",
    "    case _ => println(\"Didn't match anything\")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regular Expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123 and 456\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[36mregEx\u001b[0m: \u001b[32mutil\u001b[0m.\u001b[32mmatching\u001b[0m.\u001b[32mRegex\u001b[0m = \\d+"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// All regexes are instance of util.matching.Regex\n",
    "\n",
    "// To create one - use th r method\n",
    "val regEx = \"\"\"\\d+\"\"\".r\n",
    "\n",
    "// Then we ca use various matching/finding method\n",
    "println ((regEx findAllIn \"123 abcxyz 456\").mkString(\" and \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "group 1=123 group2= xyz  group3=456\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[36mpattern\u001b[0m: \u001b[32mutil\u001b[0m.\u001b[32mmatching\u001b[0m.\u001b[32mRegex\u001b[0m = (\\d+)(\\D*)(\\d+)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// RegEx acts as an extractor - Scala gives it an unapply method, which returns the regex groups\n",
    "val pattern = \"\"\"(\\d+)(\\D*)(\\d+)\"\"\".r\n",
    "\n",
    "\"123 xyz 456\" match{\n",
    "    case pattern(x, y, z) => println(s\"group 1=$x group2=$y group3=$z\")\n",
    "    case _ => println(\"Didn't match\")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='exception_handling'/>\n",
    "# Exception Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ERROR\n",
      "Just like in Java!\n"
     ]
    },
    {
     "data": {
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "//All exceptions are unchecked\n",
    "try {\n",
    "    throw new IllegalArgumentException(\"ERROR\")\n",
    "} catch {\n",
    "    // Use case syntax to handle specific exceptions\n",
    "    case e: NumberFormatException => println(e.getMessage)\n",
    "    case e: IllegalArgumentException => println(e.getMessage)\n",
    "    case _: Throwable => println(\"Random Error\")\n",
    "} finally {\n",
    "    println(\"Just like in Java!\")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='lazy_evaluation_streams_generators'/>\n",
    "# Lazy Evaluation and Streams/Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Will no actially execute f now\n",
      "Using lazyX - will run f now\n",
      "Executing f ...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mf\u001b[0m\n",
       "\u001b[36mlazyX\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m<lazy>\u001b[0m\n",
       "\u001b[36mx\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m10\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Some \"expensive\" function\n",
    "def f():Int = {\n",
    "    println(\"Executing f ...\")\n",
    "    return 5\n",
    "}\n",
    "\n",
    "// Define a lazy constant - will not be run until it is used\n",
    "println(\"Will no actially execute f now\")\n",
    "lazy val lazyX = f\n",
    "\n",
    "// Will run f now, as lazyX is used\n",
    "println(\"Using lazyX - will run f now\")\n",
    "val x = lazyX + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======== Eager =========\n",
      "Called for 1\n",
      "Called for 2\n",
      "Called for 3\n",
      "======== Lazy =========\n",
      "Called for 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mpred\u001b[0m\n",
       "\u001b[36mres76_2\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m1\u001b[0m\n",
       "\u001b[36mv\u001b[0m: \u001b[32mInt\u001b[0m = \u001b[32m1\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def pred(s:Int):Boolean = {\n",
    "    println(s\"Called for ${s}\")\n",
    "    s == 1\n",
    "}\n",
    "\n",
    "println(\"======== Eager =========\")\n",
    "\n",
    "// Will call the predicate for every element, althoug the result is never used\n",
    "Vector(1,2,3).filter(pred).head // pred executes for all elements\n",
    "\n",
    "println(\"======== Lazy =========\")\n",
    "\n",
    "// The \"view\" function creates a lazy collection/view. The predicate is called just once!\n",
    "val v = Vector(1,2,3).view.filter(pred).head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Stream(0, ?)\n",
      "Stream(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n",
      "List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36minfStream\u001b[0m\n",
       "\u001b[36mstr\u001b[0m: \u001b[32mStream\u001b[0m[\u001b[32mInt\u001b[0m] = \u001b[33mStream\u001b[0m(\n",
       "  \u001b[32m0\u001b[0m,\n",
       "  \u001b[32m1\u001b[0m,\n",
       "  \u001b[32m2\u001b[0m,\n",
       "  \u001b[32m3\u001b[0m,\n",
       "  \u001b[32m4\u001b[0m,\n",
       "  \u001b[32m5\u001b[0m,\n",
       "  \u001b[32m6\u001b[0m,\n",
       "  \u001b[32m7\u001b[0m,\n",
       "  \u001b[32m8\u001b[0m,\n",
       "  \u001b[32m9\u001b[0m,\n",
       "  \u001b[32m10\u001b[0m,\n",
       "  \u001b[32m11\u001b[0m,\n",
       "  \u001b[32m12\u001b[0m,\n",
       "  \u001b[32m13\u001b[0m,\n",
       "\u001b[33m...\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Scala streams are similar to Java streams and Python generators.\n",
    "def infStream(from:Int): Stream[Int] = {\n",
    "    // #:: creates a stream of a first element and \"a delayed execution\"\n",
    "    from #:: infStream(from + 1)\n",
    "}\n",
    "\n",
    "// The value of str is Stream[0, <delayed computation>]\n",
    "val str = infStream(0)\n",
    "\n",
    "println(str.head) // Prints 0\n",
    "println(str.take(10)) //Stream[0, <delayed computation>]\n",
    "println(str.take(10).force) //Stream[0, ..., 10]\n",
    "println(str.take(10).toList) //List[0, ..., 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='parallel_collections'/>\n",
    "# Parallel Collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ParVector(2, 4, 6)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[36mp\u001b[0m: \u001b[32mcollection\u001b[0m.\u001b[32mparallel\u001b[0m.\u001b[32mimmutable\u001b[0m.\u001b[32mParSeq\u001b[0m[\u001b[32mInt\u001b[0m] = ParVector(1, 2, 3)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Similar to Java 8's parallel stream. The 'par' method converts a collection to a\n",
    "// ParVector, which runs most operations in parallel\n",
    "val p = List(1,2,3).par\n",
    "\n",
    "// Could run the computation is parallel\n",
    "println(p.map(_ * 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='miscellaneous'/>\n",
    "# Miscellaneous"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Semicolon operators - left/right associativity of operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When an operator name ends with \":\" - it is applied to the object following its instantiation. This is how /: works for folding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "subject:a2; param: a1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass \u001b[36mA\u001b[0m\n",
       "\u001b[36ma1\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mA\u001b[0m = cmd61$$user$A@38b297a9\n",
       "\u001b[36ma2\u001b[0m: \u001b[32m$user\u001b[0m.\u001b[32mA\u001b[0m = cmd61$$user$A@1a295ab5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class A(val name:String) {\n",
    "    def &:(a:A) = println(s\"subject:$name; param: ${a.name}\")\n",
    "}\n",
    "val a1 = new A(\"a1\")\n",
    "val a2 = new A(\"a2\")\n",
    "a1 &: a2 // Outputs: \"subject:a2; param: a1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Scala 2.11",
   "language": "scala211",
   "name": "scala211"
  },
  "language_info": {
   "codemirror_mode": "text/x-scala",
   "file_extension": ".scala",
   "mimetype": "text/x-scala",
   "name": "scala211",
   "pygments_lexer": "scala",
   "version": "2.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}