Added regular expresison patterns to tour

Author: jsuereth

tour/automatic-closures.md

@@ -0,0 +1,58 @@
+---
+layout: overview
+title: Automatic Type-Dependent Closure Construction
+---
+
+Scala allows parameterless function names as parameters of methods. When such a method is called, the actual parameters for parameterless function names are not evaluated and a nullary function is passed instead which encapsulates the computation of the corresponding parameter (so-called *call-by-name* evalutation).
+
+The following code demonstrates this mechanism:
+
+    object TargetTest1 extends Application {
+      def whileLoop(cond: => Boolean)(body: => Unit): Unit =
+        if (cond) {
+          body
+          whileLoop(cond)(body)
+        }
+      var i = 10
+      whileLoop (i > 0) {
+        println(i)
+        i -= 1
+      }
+    }
+
+The function whileLoop takes two parameters `cond` and `body`. When the function is applied, the actual parameters do not get evaluated. But whenever the formal parameters are used in the body of `whileLoop`, the implicitly created nullary functions will be evaluated instead. Thus, our method `whileLoop` implements a Java-like while-loop with a recursive implementation scheme.
+
+We can combine the use of [infix/postfix operators](operators.html) with this mechanism to create more complex statements (with a nice syntax).
+
+Here is the implementation of a loop-unless statement:
+
+    object TargetTest2 extends Application {
+      def loop(body: => Unit): LoopUnlessCond =
+        new LoopUnlessCond(body)
+      protected class LoopUnlessCond(body: => Unit) {
+        def unless(cond: => Boolean) {
+          body
+          if (!cond) unless(cond)
+        }
+      }
+      var i = 10
+      loop {
+        println("i = " + i)
+        i -= 1
+      } unless (i == 0)
+    }
+The `loop` function just accepts a body of a loop and returns an instance of class `LoopUnlessCond` (which encapsulates this body object). Note that the body didn't get evaluated yet. Class `LoopUnlessCond` has a method `unless` which we can use as a *infix operator*. This way, we achieve a quite natural syntax for our new loop: `loop { < stats > } unless ( < cond > )`.
+
+Here's the output when `TargetTest2` gets executed:
+
+    i = 10
+    i = 9
+    i = 8
+    i = 7
+    i = 6
+    i = 5
+    i = 4
+    i = 3
+    i = 2
+    i = 1
+

tour/index.md

@@ -11,7 +11,7 @@ Scala is a pure object-oriented language in the sense that [every value is an ob
 ## Scala is functional ##
 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.
+Furthermore, Scala's notion of pattern matching naturally extends to the processing of XML data with the help of (right-ignoring sequence patterns)[regular-expression-patterns.html]. In this context, [sequence comprehensions](sequence-comprehensions.html) 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:
@@ -29,8 +29,8 @@ A [local type inference mechanism](local-type-inference.html) takes care that th
 ## 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).
+* any method may be used as an [infix or postfix operator](operators.html)
+* [closures are constructed automatically depending on the expected type](automatic-closures.html) (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

tour/operators.md

@@ -0,0 +1,24 @@
+---
+layout: overview
+title: Operators
+---
+
+Any method which takes a single parameter can be used as an *infix operator* in Scala. Here is the definition of class `MyBool` which defines three methods `and`, `or`, and `negate`.
+
+    class MyBool(x: Boolean) {
+      def and(that: MyBool): MyBool = if (x) that else this
+      def or(that: MyBool): MyBool = if (x) this else that
+      def negate: MyBool = new MyBool(!x)
+    }
+
+It is now possible to use `and` and `or` as infix operators:
+
+    def not(x: MyBool) = x negate; // semicolon required here
+    def xor(x: MyBool, y: MyBool) = (x or y) and not(x and y)
+
+As the first line of this code shows, it is also possible to use nullary methods as postfix operators. The second line defines an xor function using the and and or methods as well as the new `not` function. In this example the use of _infix operators_ helps to make the definition of `xor` more readable.
+
+Here is the corresponding code in a more traditional object-oriented programming language syntax:
+
+    def not(x: MyBool) = x.negate; // semicolon required here
+    def xor(x: MyBool, y: MyBool) = x.or(y).and(x.and(y).negate)

tour/regular-expression-patterns.md

@@ -0,0 +1,33 @@
+---
+layout: overview
+title: Regular Expression Patterns
+---
+
+## Right-ignoring sequence patterns ##
+
+Right-ignoring patterns are a useful feature to decompose any data which is either a subtype of Seq[A] or a case class with an iterated formal parameter, like for instance
+
+    Elem(prefix:String, label:String, attrs:MetaData, scp:NamespaceBinding, children:Node*)
+
+In those cases, Scala allows patterns having a wildcard-star `_*` in the rightmost position to stand for arbitrary long sequences.
+The following example demostrate a pattern match which matches a prefix of a sequence and binds the rest to the variable `rest`.
+
+    object RegExpTest1 extends Application {
+      def containsScala(x: String): Boolean = {
+        val z: Seq[Char] = x
+        z match {
+          case Seq('s','c','a','l','a', rest @ _*) =>
+            println("rest is "+rest)
+            true
+          case Seq(_*) =>
+            false
+        }
+      }
+    }
+
+In contrast to previous Scala version, it is no longer allowed to have arbitrary regular expressions, for the reasons described below.
+General `RegExp` patterns temporarily retracted from Scala
+
+Since we discovered a problem in correctness, this feature is temporarily retracted from the Scala language. If there is request from the user community, we might reactivate it in an improved form.
+
+According to our opinion regular expressions patterns were not so useful for XML processing as we estimated. In real life XML processing applications, XPath seems a far better option. When we discovered that our translation or regular expressions patterns has some bugs for esoteric patterns which are unusual yet hard to exclude, we chose it would be time to simplify the language.

tour/sequence-comprehensions.md

@@ -0,0 +1,51 @@
+---
+layout: overview
+title: Sequence Comprehensions
+---
+
+Scala offers a lightweight notation for expressing *sequence comprehensions*. Comprehensions have the form `for (enumerators) yield e`, where `enumerators` refers to a semicolon-separated list of enumerators. An *enumerator* is either a generator which introduces new variables, or it is a filter. A comprehension evaluates the body `e` for each binding generated by the enumerators and returns a sequence of these values.
+
+Here is an example:
+ 
+    object ComprehensionTest1 extends Application {
+      def even(from: Int, to: Int): List[Int] =
+        for (i <- List.range(from, to) if i % 2 == 0) yield i
+      Console.println(even(0, 20))
+    }
+ 
+The for-expression in function introduces a new variable `i` of type `Int` which is subsequently bound to all values of the list `List(from, from + 1, ..., to - 1)`. The guard `if i % 2 == 0` filters out all odd numbers so that the body (which only consists of the expression i) is only evaluated for even numbers. Consequently, the whole for-expression returns a list of even numbers.
+
+The program yields the following output:
+
+    List(0, 2, 4, 6, 8, 10, 12, 14, 16, 18)
+
+Here is a more complicated example which computes all pairs of numbers between `0` and `n-1` whose sum is equal to a given value `v`:
+ 
+    object ComprehensionTest2 extends Application {
+      def foo(n: Int, v: Int) =
+        for (i <- 0 until n;
+             j <- i + 1 until n if i + j == v) yield
+          Pair(i, j);
+      foo(20, 32) foreach {
+        case (i, j) =>
+          println("(" + i + ", " + j + ")")
+      }
+    }
+ 
+This example shows that comprehensions are not restricted to lists. The previous program uses iterators instead. Every datatype that supports the operations `filterWith`, `map`, and `flatMap` (with the proper types) can be used in sequence comprehensions.
+
+Here's the output of the program:
+
+    (13, 19)
+    (14, 18)
+    (15, 17)
+
+There is also a special form of sequence comprehension which returns `Unit`. Here the bindings that are created from the list of generators and filters are used to perform side-effects. The programmer has to omit the keyword `yield` to make use of such a sequence comprehension.
+Here's a program which is equivalent to the previous one but uses the special for comprehension returning `Unit`:
+ 
+    object ComprehensionTest3 extends Application {
+      for (i <- Iterator.range(0, 20);
+           j <- Iterator.range(i + 1, 20) if i + j == 32)
+        println("(" + i + ", " + j + ")")
+    }
+