Added more to tour

Author: jsuereth

tour/anonymous-function-syntax.md

@@ -0,0 +1,34 @@
+---
+layout: overview
+title: Anonymous Function Syntax
+---
+
+Scala provides a relatively lightweight syntax for defining anonymous functions. The following expression creates a successor function for integers:
+
+    (x: Int) => x + 1
+
+This is a shorthand for the following anonymous class definition:
+
+    new Function1[Int, Int] {
+      def apply(x: Int): Int = x + 1
+    }
+
+It is also possible to define functions with multiple parameters:
+
+    (x: Int, y: Int) => "(" + x + ", " + y + ")"
+
+or with no parameter:
+
+    () => { System.getProperty("user.dir") }
+
+There is also a very lightweight way to write function types. Here are the types of the three functions defined above:
+
+    Int => Int
+    (Int, Int) => String
+    () => String
+
+This syntax is a shorthand for the following types:
+
+    Function1[Int, Int]
+    Function2[Int, Int, String]
+    Function0[String]

tour/case-classes.md

@@ -0,0 +1,68 @@
+---
+layout: overview
+title: Case Classes
+---
+
+Scala supports the notion of _case classes_. Case classes are regular classes which export their constructor parameters and which provide a recursive decomposition mechanism via [pattern matching](pattern-matching.html).
+
+Here is an example for a class hierarchy which consists of an abstract super class Term and three concrete case classes `Var`, `Fun`, and `App`.
+
+    abstract class Term
+    case class Var(name: String) extends Term
+    case class Fun(arg: String, body: Term) extends Term
+    case class App(f: Term, v: Term) extends Term
+
+This class hierarchy can be used to represent terms of the [untyped lambda calculus](http://www.ezresult.com/article/Lambda_calculus). To facilitate the construction of case class instances, Scala does not require that the new primitive is used. One can simply use the class name as a function.
+
+Here is an example:
+
+    Fun("x", Fun("y", App(Var("x"), Var("y"))))
+
+The constructor parameters of case classes are treated as public values and can be accessed directly.
+
+    val x = Var("x")
+    Console.println(x.name)
+
+For every case class the Scala compiler generates equals method which implements structural equality and a `toString` method. For instance:
+
+    val x1 = Var("x")
+    val x2 = Var("x")
+    val y1 = Var("y")
+    println("" + x1 + " == " + x2 + " => " + (x1 == x2))
+    println("" + x1 + " == " + y1 + " => " + (x1 == y1))
+    will print
+    Var(x) == Var(x) => true
+    Var(x) == Var(y) => false
+
+It makes only sense to define case classes if pattern matching is used to decompose data structures. The following object defines a pretty printer function for our lambda calculus representation:
+
+    object TermTest extends Application {
+      def printTerm(term: Term) {
+        term match {
+          case Var(n) =>
+            print(n)
+          case Fun(x, b) =>
+            print("^" + x + ".")
+            printTerm(b)
+          case App(f, v) =>
+            Console.print("(")
+            printTerm(f)
+            print(" ")
+            printTerm(v)
+            print(")")
+        }
+      }
+      def isIdentityFun(term: Term): Boolean = term match {
+        case Fun(x, Var(y)) if x == y => true
+        case _ => false
+      }
+      val id = Fun("x", Var("x"))
+      val t = Fun("x", Fun("y", App(Var("x"), Var("y"))))
+      printTerm(t)
+      println
+      println(isIdentityFun(id))
+      println(isIdentityFun(t))
+    }
+
+In our example, the function `print` is expressed as a pattern matching statement starting with the `match` keyword and consisting of sequences of `case Pattern => Body` clauses.
+The program above also defines a function `isIdentityFun` which checks if a given term corresponds to a simple identity function. This example uses deep patterns and guards. After matching a pattern with a given value, the guard (defined after the keyword `if`) is evaluated. If it returns `true`, the match succeeds; otherwise, it fails and the next pattern will be tried.

tour/currying.md

@@ -0,0 +1,29 @@
+---
+layout: overview
+title: Currying
+---
+
+Methods may define multiple parameter lists. When a method is called with a fewer number of parameter lists, then this will yield a function taking the missing parameter lists as its arguments.
+
+Here is an example:
+
+    object CurryTest extends Application {
+    
+      def filter(xs: List[Int], p: Int => Boolean): List[Int] =
+        if (xs.isEmpty) xs
+        else if (p(xs.head)) xs.head :: filter(xs.tail, p)
+        else filter(xs.tail, p)
+    
+      def modN(n: Int)(x: Int) = ((x % n) == 0)
+    
+      val nums = List(1, 2, 3, 4, 5, 6, 7, 8)
+      println(filter(nums, modN(2)))
+      println(filter(nums, modN(3)))
+    }
+
+_Note: method `modN` is partially applied in the two `filter` calls; i.e. only its first argument is actually applied. The `termmodN(2)` yields a function of type `Int => Boolean` and is thus a possible candidate for the second argument of function `filter`._
+
+Here's the output of the program above:
+
+    List(2,4,6,8)
+    List(3,6)

tour/extractor-objects.md

@@ -0,0 +1,30 @@
+---
+layout: overview
+title: Extractor Objects
+---
+
+In Scala, patterns can be defined independently of case classes. To this end, a method named unapply is defined to yield a so-called extractor. For instance, the following code defines an extractor object Twice.
+
+    object Twice {
+      def apply(x: Int): Int = x * 2
+      def unapply(z: Int): Option[Int] = if (z%2 == 0) Some(z/2) else None
+    }
+    
+    object TwiceTest extends Application {
+      val x = Twice(21)
+      x match { case Twice(n) => Console.println(n) } // prints 21
+    }
+There are two syntactic conventions at work here:
+
+The pattern `case Twice(n)` will cause an invocation of `Twice.unapply`, which is used to match any even number; the return value of the `unapply` signals whether the argument has matched or not, and any sub-values that can be used for further matching. Here, the sub-value is `z/2`
+
+The `apply` method is not necessary for pattern matching.  It is only used to mimick a constructor. `val x = Twice(21)` expands to `val x = Twice.apply(21)`.
+
+The return type of an `unapply` should be chosen as follows:
+* If it is just a test, return a `Boolean`. For instance `case even()`
+* If it returns a single sub-value of type T, return an `Option[T]`
+* If you want to return several sub-values `T1,...,Tn`, group them in an optional tuple `Option[(T1,...,Tn)]`.
+
+Sometimes, the number of sub-values is fixed and we would like to return a sequence. For this reason, you can also define patterns through `unapplySeq`. The last sub-value type `Tn` has to be `Seq[S]`. This mechanism is used for instance in pattern `case List(x1, ..., xn)`.
+
+Extractors can make code more maintainable. For details, read the paper ["Matching Objects with Patterns"](http://lamp.epfl.ch/~emir/written/MatchingObjectsWithPatterns-TR.pdf) (see section 4) by Emir, Odersky and Williams (January 2007).

tour/higher-order-functions.md

@@ -0,0 +1,28 @@
+---
+layout: overview
+title: Higher-order Functions
+---
+
+Scala allows the definition of higher-order functions. These are functions that _take other functions as parameters_, or whose _result is a function_. Here is a function `apply` which takes another function `f` and a value `v` and applies function `f` to `v`:
+
+    def apply(f: Int => String, v: Int) = f(v)
+
+_Note: methods are automatically coerced to functions if the context requires this._
+
+Here is another example:
+ 
+    class Decorator(left: String, right: String) {
+      def layout[A](x: A) = left + x.toString() + right
+    }
+    
+    object FunTest extends Application {
+      def apply(f: Int => String, v: Int) = f(v)
+      val decorator = new Decorator("[", "]")
+      println(apply(decorator.layout, 7))
+    }
+ 
+Execution yields the output:
+
+    [7]
+
+In this example, the method `decorator.layout` is coerced automatically to a value of type `Int => String` as required by method `apply`. Please note that method `decorator.layout` is a _polymorphic method_ (i.e. it abstracts over some of its signature types) and the Scala compiler has to instantiate its method type first appropriately.

tour/index.md

@@ -9,7 +9,7 @@ Scala is a modern multi-paradigm programming language designed to express common
 Scala is a pure object-oriented language in the sense that [every value is an object](unified_types.html). Types and behavior of objects are described by [classes](classes.html) and [traits](traits.html). Classes are extended by subclassing and a flexible [mixin-based composition](mixin-class-composition.html) mechanism as a clean replacement for multiple inheritance.
 
 ## Scala is functional ##
-Scala is also a functional language in the sense that every function is a value. Scala provides a lightweight syntax for defining anonymous functions, it supports higher-order functions, it allows functions to be nested, and supports currying. Scala's case classes and its built-in support for pattern matching model algebraic types used in many functional programming languages.
+Scala is also a functional language in the sense that [every function is a value](unified_types.html). Scala provides a [lightweight syntax](anonymous-function-syntax.html) for defining anonymous functions, it supports [higher-order functions](higher-order-functions.html), it allows functions to be [nested](nested-functions.html), and supports [currying](currying.html). Scala's [case classes](case-classes.html) and its built-in support for [pattern matching](pattern-matching.html) model algebraic types used in many functional programming languages.
 
 Furthermore, Scala's notion of pattern matching naturally extends to the processing of XML data with the help of right-ignoring sequence patterns. In this context, sequence comprehensions are useful for formulating queries. These features make Scala ideal for developing applications like web services.
 

tour/nested-functions.md

@@ -0,0 +1,23 @@
+---
+layout: overview
+title: Nested Functions
+---
+
+In Scala it is possible to nest function definitions. The following object provides a `filter` function for extracting values from a list of integers that are below a threshold value:
+
+    object FilterTest extends Application {
+      def filter(xs: List[Int], threshold: Int) = {
+        def process(ys: List[Int]): List[Int] =
+          if (ys.isEmpty) ys
+          else if (ys.head < threshold) ys.head :: process(ys.tail)
+          else process(ys.tail)
+        process(xs)
+      }
+      println(filter(List(1, 9, 2, 8, 3, 7, 4), 5))
+    }
+
+_Note: the nested function `process` refers to variable `threshold` defined in the outer scope as a parameter value of `filter`._
+
+The output of this program is:
+
+    List(1,2,3,4)

tour/pattern-matching.md

@@ -0,0 +1,34 @@
+---
+layout: overview
+title: Pattern Matching
+---
+
+Scala has a built-in general pattern matching mechanism. It allows to match on any sort of data with a first-match policy. 
+Here is a small example which shows how to match against an integer value:
+
+    object MatchTest1 extends Application {
+      def matchTest(x: Int): String = x match {
+        case 1 => "one"
+        case 2 => "two"
+        case _ => "many"
+      }
+      println(matchTest(3))
+    }
+
+The block with the `case` statements defines a function which maps integers to strings. The `match` keyword provides a convenient way of applying a function (like the pattern matching function above) to an object.
+
+Here is a second example which matches a value against patterns of different types:
+
+    object MatchTest2 extends Application {
+      def matchTest(x: Any): Any = x match {
+        case 1 => "one"
+        case "two" => 2
+        case y: Int => "scala.Int"
+      }
+      println(matchTest("two"))
+    }
+
+The first `case` matches if `x` refers to the integer value `1`. The second `case` matches if `x` is equal to the string `"two"`. The third case consists of a typed pattern; it matches against any integer and binds the selector value `x` to the variable `y` of type integer.
+
+Scala's pattern matching statement is most useful for matching on algebraic types expressed via [case classes](case-classes.html).
+Scala also allows the definition of patterns independently of case classes, using unapply methods in [extractor objects](extractor-objects.html).