week 3

Author: iirvine

.gitignore

@@ -11,6 +11,7 @@ project/plugins/project/
 
 # Scala-IDE specific
 .scala_dependencies
+.cache
 
 # Eclipse
 .metadata

notes/week 3/002-how-classes-are-organized.md

@@ -0,0 +1,59 @@
+###Packages
+
+Generally in Scala, as in Java, classes are organized into packages; using a package clause at the top of your source file.
+
+###Traits
+
+In Java, as well as in Scala, a class can only have one superclass - it's a single inheritance language. In practice this can be quite constraining; often times a type would naturally have several super types, or you want to inherit behavior from several super entities that all contribute to the final code of the class.
+
+To do that we can use a concept called *traits*; they're essentially declared like an abstract class, but with `trait` instead of `abstract`
+
+```scala
+	def height: Int
+	def width: Int
+	def surface = height * width
+```
+
+Classes, objects, and traits can inherit from at most one class but arbitrarily many traits:
+
+```scala
+class Square Shape with Planar with Movable
+```
+
+Traits resemble interfaces in Java but are more powerful - they can contain fields and concrete methods. These implementations can be overridden in subclasses. On the other hand, traits cannot have (value) parameters - only classes can (like the numerator and denominator of class `Rational`).
+
+###Top Types
+At the top of the scala type hierarchy we find:
+
+* `Any`  the base type of all types. It defines methods like '==', '!=', 'hashCode', and 'toString'
+* `AnyRef`	the base type of all reference types; an alias of `java.lang.Object`
+* `AnyVal`	the base type of all primitive types; for now these are just the primitives that scala inherits from java
+
+###The Nothing Type
+
+`Nothing` is at the bottom of scala's type hierarchy - it is a subtype of every other type.
+
+There is no value of type `Nothing` - why is that useful?
+
+* to signal abnormal termination; sometimes a function would not return, but instead throw an exception or terminate the program. What would the return type of that function be? The best possible type is nothing - it doesn't return anything.
+* as an element type of empty collections (like Set[Nothing])
+
+###Exceptions
+Scala's exception handling is similar to Java:
+
+```scala
+throw Exc
+```
+
+aborts evaluation with the exception Exc - the type of this expression is `Nothing`.
+
+###Null
+Every reference class type also has `null` as a value - when somebody expects a string, you could pass it null. The type of `null` is `Null`.
+
+`Null` is a subtype of every class that inherits from `Object` - it is incompatible with subtypes of `AnyVal`
+
+```scala
+val x = null
+val y: String = x
+val z: Int = null //Throws a type mismatch error
+```

notes/week 3/003-polymorphism.md

@@ -0,0 +1,89 @@
+###Polymorphism
+
+As a motivating example, let's look at a datastructure that's been fundamental in many functional languages from the beginnings - the Cons-List
+
+It is an immutable linked list, constructed from two building blocks:
+
+* the empty list, which we call `Nil`
+* a cell containg an element and a pointer to the remainder of the list, called `Cons`
+
+Here's what `List(1,2,3)` would look like:
+![img](http://i.imgur.com/Cbla4yn.png)
+
+We'd have a reference to a `Cons` cell that contains the 1, and a reference to a `Cons` cell that contains 2, which has a reference to a `Cons` cell that contains 3, which has a reference to `Nil`
+
+A nested list like `List(List(true, false), List(3))` would look like:
+![img](http://i.imgur.com/XYcKqde.png)
+
+###Cons-Lists in scala
+How would we write this as a class hierarchy in scala?
+
+Here's an outline that would represent lists of integers in this fashion:
+
+```scala
+trait IntList ...
+class Cons(val head: Int, val tail: IntList) extends IntList ...
+class Nil extends IntList ...
+```
+
+Notice there's a bit of new syntax in the `Cons` declaration - `val head: Int` defines a parameter and a field definition in the class itself. It's equivalent to:
+
+```scala
+class Cons(_head: Int, _tail:IntList) extends IntList {
+	val head = _head
+	val tail = _tail
+}
+```
+
+A list is either
+
+* an empty list `new Nil`, or
+* a list `Cons(x, xs) consisting of a `head` element x and a `tail` list xs
+
+###Type Parameters
+There's one problem with our type hierarchy - it's way too narrow to only define lists with `Int` elements. If we did it that way, we'd need a type hierarchy for `Double`, `Boolean`, and so on...
+
+What we need to do is generalize the definition - we can do that using the `type` parameter
+
+```scala
+trait List[T]
+class Cons[T](val: head T, val tail: List[T]) extends List[T]
+class Nil[T] extends List[T]
+```
+
+So, we're going to define a base trait, List, which takes a type parameter `T`. That base trait List[T] will have two subclasses, `Cons[T]` and `Nil[T]`. `Cons[T]` will now have a head element of type `T`, and a tail element of type `List[T]`
+
+###Generic Functions
+Like classes, functions can have type parameters. For instance, here's a function that creates a list consisting of a single element:
+
+```scala
+def singleton[T](elem: T) = new Cons[T](elem, new Nil[T])
+```
+
+We can then write:
+
+```scala
+singleton[Int](1)
+singleton[Boolean](true)
+```
+
+###Type Inference
+The scala compiler can usually deduce the correct type parameters from the value arguments of a function call - so in most cases the type parameters can be left out. The above could just be written as:
+
+```scala
+singleton(1)
+singleton(true)
+```
+
+###Types and Evaluation
+
+Type parameters do not affect evaluation in scala at all - we can assume that all type parameters and type arguments are removed before evaluation of the program. This is called *type erasure*. Types are only important for the compiler to verify that the program satisfies certain correctness properties, but they're not relevant for the actual execution.
+
+###Polymorphism
+Polymorphism means that a function type comes "in many forms" - basically, the function can be applied to arguments of many types, or the type can have instances of many types.
+
+We have seen two principle forms of polymorphism - subtyping, and generics.
+
+Subtyping means that instances of a subclass can be passed to a base class - ie, given our `List` hierarchy, anywhere we have a parameter that accepts type `List`, we can pass either a `Nil` or a `Cons`.
+
+Generics means that we can create many instances of a function or class by type parameterization. By using generics, we could create a `List[Int]`, or a `List[List[Boolean]]`, whatever dawg.

notes/week 3/src/Cons/List.scala

@@ -0,0 +1,17 @@
+package Cons
+
+trait List[T] {
+	def isEmpty: Boolean
+	def head: T
+	def tail: List[T]
+}
+
+class Cons[T](val head: T, val tail: List[T]) extends List[T] {
+  def isEmpty = false
+}
+
+class Nil[T] extends List[T] {
+  def isEmpty = true
+  def head = throw new NoSuchElementException("Nil.head")
+  def tail = throw new NoSuchElementException("Nil.tail")
+}

notes/week 3/src/Cons/nth.sc

@@ -0,0 +1,24 @@
+package Cons
+
+object nth {
+  def nth[T](n: Int, xs: List[T]): T =
+  	if (xs.isEmpty) throw new IndexOutOfBoundsException
+  	else if (n == 0) xs.head
+  	else nth(n - 1, xs.tail)                  //> nth: [T](n: Int, xs: Cons.List[T])T
+  	
+  val list = new Cons(1, new Cons(2, new Cons(3, new Nil)))
+                                                  //> list  : Cons.Cons[Int] = Cons.Cons@418c56d
+  
+  nth(2, list)                                    //> res0: Int = 3
+  nth(-1, list)                                   //> java.lang.IndexOutOfBoundsException
+                                                  //| 	at Cons.nth$$anonfun$main$1.nth$1(Cons.nth.scala:5)
+                                                  //| 	at Cons.nth$$anonfun$main$1.apply$mcV$sp(Cons.nth.scala:12)
+                                                  //| 	at org.scalaide.worksheet.runtime.library.WorksheetSupport$$anonfun$$exe
+                                                  //| cute$1.apply$mcV$sp(WorksheetSupport.scala:76)
+                                                  //| 	at org.scalaide.worksheet.runtime.library.WorksheetSupport$.redirected(W
+                                                  //| orksheetSupport.scala:65)
+                                                  //| 	at org.scalaide.worksheet.runtime.library.WorksheetSupport$.$execute(Wor
+                                                  //| ksheetSupport.scala:75)
+                                                  //| 	at Cons.nth$.main(Cons.nth.scala:3)
+                                                  //| 	at Cons.nth.main(Cons.nth.scala)
+}