Added OO parts of tour of scala

Author: jsuereth

tour/classes.md

@@ -0,0 +1,39 @@
+---
+layout: overview
+title: Classes
+---
+
+Classes in Scala are static templates that can be instantiated into many objects at runtime.
+Here is a class definition which defines a class `Point`:
+
+    class Point(xc: Int, yc: Int) {
+      var x: Int = xc
+      var y: Int = yc
+      def move(dx: Int, dy: Int) {
+        x = x + dx
+        y = y + dy
+      }
+      override def toString(): String = "(" + x + ", " + y + ")";
+    }
+
+The class defines two variables `x` and `y` and two methods: `move` and `toString`. `move` takes two integer arguments but does not return a value (the implicit return type `Unit` corresponds to `void` in Java-like languages). `toString`, on the other hand, does not take any parameters but returns a `String` value. Since `toString` overrides the pre-defined `toString` method, it has to be tagged with the `override` flag.
+
+Classes in Scala are parameterized with constructor arguments. The code above defines two constructor arguments, `xc` and `yc`; they are both visible in the whole body of the class. In our example they are used to initialize the variables `x` and `y`.
+
+Classes are instantiated with the new primitive, as the following example will show:
+
+    object Classes {
+      def main(args: Array[String]) {
+        val pt = new Point(1, 2)
+        println(pt)
+        pt.move(10, 10)
+        println(pt)
+      }
+    }
+
+The program defines an executable application Classes in form of a top-level singleton object with a `main` method. The `main` method creates a new `Point` and stores it in value `pt`. _Note that values defined with the `val` construct are different from variables defined with the `var` construct (see class `Point` above) in that they do not allow updates; i.e. the value is constant._
+
+Here is the output of the program:
+
+    (1, 2)
+    (11, 12)

tour/index.md

@@ -0,0 +1,40 @@
+---
+layout: overview
+title: Tour of Scala
+---
+
+Scala is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages.
+
+## Scala is object-oriented ##
+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.
+
+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.
+
+## Scala is statically typed ##
+Scala is equipped with an expressive type system that enforces statically that abstractions are used in a safe and coherent manner. In particular, the type system supports:
+* generic classes
+* variance annotations
+* upper and lower type bounds,
+* inner classes and abstract types as object members
+* compound types
+* explicitly typed self references
+* views
+* polymorphic methods
+
+A local type inference mechanism takes care that the user is not required to annotate the program with redundant type information. In combination, these features provide a powerful basis for the safe reuse of programming abstractions and for the type-safe extension of software.
+
+## Scala is extensible ##
+
+In practice, the development of domain-specific applications often requires domain-specific language extensions. Scala provides a unique combination of language mechanisms that make it easy to smoothly add new language constructs in form of libraries:
+* any method may be used as an infix or postfix operator
+* closures are constructed automatically depending on the expected type (target typing).
+
+A joint use of both features facilitates the definition of new statements without extending the syntax and without using macro-like meta-programming facilities.
+Scala interoperates with Java and .NET
+
+Scala is designed to interoperate well with the popular Java 2 Runtime Environment (JRE). In particular, the interaction with the mainstream object-oriented Java programming language is as smooth as possible. Scala has the same compilation model (separate compilation, dynamic class loading) like Java and allows access to thousands of existing high-quality libraries. Support for the .NET Framework (CLR) is also available.
+
+Please continue to the next page to read more.

tour/mixin-class-composition.md

@@ -0,0 +1,39 @@
+---
+layout: overview
+title: Mixin Class Composition
+---
+
+As opposed to languages that only support _single inheritance_, Scala has a more general notion of class reuse. Scala makes it possible to reuse the _new member definitions of a class_ (i.e. the delta in relationship to the superclass) in the definition of a new class. This is expressed as a _mixin-class composition_. Consider the following abstraction for iterators.
+ 
+    abstract class AbsIterator {
+      type T
+      def hasNext: Boolean
+      def next: T
+    }
+ 
+Next, consider a mixin class which extends `AbsIterator` with a method `foreach` which applies a given function to every element returned by the iterator. To define a class that can be used as a mixin we use the keyword `trait`.
+ 
+    trait RichIterator extends AbsIterator {
+      def foreach(f: T => Unit) { while (hasNext) f(next) }
+    }
+ 
+Here is a concrete iterator class, which returns successive characters of a given string:
+ 
+    class StringIterator(s: String) extends AbsIterator {
+      type T = Char
+      private var i = 0
+      def hasNext = i < s.length()
+      def next = { val ch = s charAt i; i += 1; ch }
+    }
+ 
+We would like to combine the functionality of `StringIterator` and `RichIterator` into a single class. With single inheritance and interfaces alone this is impossible, as both classes contain member impementations with code. Scala comes to help with its _mixin-class composition_. It allows the programmers to reuse the delta of a class definition, i.e., all new definitions that are not inherited. This mechanism makes it possible to combine `StringIterator` with `RichIterator`, as is done in the following test program which prints a column of all the characters of a given string.
+ 
+    object StringIteratorTest {
+      def main(args: Array[String]) {
+        class Iter extends StringIterator(args(0)) with RichIterator
+        val iter = new Iter
+        iter foreach println
+      }
+    }
+ 
+The `Iter` class in function `main` is constructed from a mixin composition of the parents `StringIterator` and `RichIterator` with the keyword `with`. The first parent is called the _superclass_ of `Iter`, whereas the second (and every other, if present) parent is called a _mixin_.

tour/traits.md

@@ -0,0 +1,36 @@
+---
+layout: overview
+title: Traits
+---
+
+Similar to interfaces in Java, traits are used to define object types by specifying the signature of the supported methods. Unlike Java, Scala allows traits to be partially implemented; i.e. it is possible to define default implementations for some methods. In contrast to classes, traits may not have constructor parameters.
+Here is an example:
+ 
+    trait Similarity {
+      def isSimilar(x: Any): Boolean
+      def isNotSimilar(x: Any): Boolean = !isSimilar(x)
+    }
+ 
+This trait consists of two methods `isSimilar` and `isNotSimilar`. While `isSimilar` does not provide a concrete method implementation (it is abstract in the terminology of Java), method `isNotSimilar` defines a concrete implementation. Consequently, classes that integrate this trait only have to provide a concrete implementation for `isSimilar`. The behavior for `isNotSimilar` gets inherited directly from the trait. Traits are typically integrated into a [class](classes.html) (or other traits) with a [mixin class composition](mixin-class-composition.html):
+ 
+    class Point(xc: Int, yc: Int) extends Similarity {
+      var x: Int = xc
+      var y: Int = yc
+      def isSimilar(obj: Any) =
+        obj.isInstanceOf[Point] &&
+        obj.asInstanceOf[Point].x == x
+    }
+    object TraitsTest extends Application {
+      val p1 = new Point(2, 3)
+      val p2 = new Point(2, 4)
+      val p3 = new Point(3, 3)
+      println(p1.isNotSimilar(p2))
+      println(p1.isNotSimilar(p3))
+      println(p1.isNotSimilar(2))
+    }
+ 
+Here is the output of the program:
+
+    false
+    true
+    true

tour/unified_types.md

@@ -0,0 +1,39 @@
+---
+layout: overview
+title: Unified Types
+---
+
+In contrast to Java, all values in Scala are objects (including numerical values and functions). Since Scala is class-based, all values are instances of a class. The diagram below illustrates the class hierarchy.
+
+![Scala Type Hierarchy](classhierarchy.img_assist_custom.png)
+
+## Scala Class Hierarchy ##
+
+The superclass of all classes scala.Any has two direct subclasses scala.AnyVal and scala.AnyRef representing two different class worlds: value classes and reference classes. All value classes are predefined; they correspond to the primitive types of Java-like languages. All other classes define reference types. User-defined classes define reference types by default; i.e. they always (indirectly) subclass scala.AnyRef. Every user-defined class in Scala implicitly extends the trait scala.ScalaObject. Classes from the infrastructure on which Scala is running (e.g. the Java runtime environment) do not extend scala.ScalaObject. If Scala is used in the context of a Java runtime environment, then scala.AnyRef corresponds to java.lang.Object.
+Please note that the diagram above also shows implicit conversions called views between the value classs.
+Here is an example that demonstrates that both numbers, characters, boolean values, and functions are objects just like every other object:
+ 
+    object UnifiedTypes {
+      def main(args: Array[String]) {
+        val set = new scala.collection.mutable.HashSet[Any]
+        set += "This is a string"  // add a string
+        set += 732                 // add a number
+        set += 'c'                 // add a character
+        set += true                // add a boolean value
+        set += main _              // add the main function
+        val iter: Iterator[Any] = set.elements
+        while (iter.hasNext) {
+          println(iter.next.toString())
+        }
+      }
+    }
+ 
+The program declares an application UnifiedTypes in form of a top-level singleton object with a main method. Themain method defines a local variable set which refers to an instance of class `HashSet[Any]`. The program adds various elements to this set. The elements have to conform to the declared set element type Any. In the end, string representations of all elements are printed out.
+
+Here is the output of the program:
+
+    c
+    true
+    <function>
+    732
+    This is a string