Fix #6: automatic section numbering.

Add chapter number to YAML, which is replace in numbering.css.
Use CSS counters for chapters, sections, subsections | examples.
Examples are detected by looking at the H3 element's id,
which redcarpet derives from the heading's title.
It must start with "Example:", and the whole title is suppressed
by a little javascript, so we can make Examples look like in the pdf.

For example, `### Example:` becomes `Example 3.2.10`,
if it's the 10th example in Section 3.2.

Author: adriaanm

03-lexical-syntax.md

@@ -1,7 +1,7 @@
 ---
 title: Lexical Syntax
 layout: default
-tag: lexical
+chapter: 1
 ---
 
 # Lexical Syntax
@@ -100,15 +100,15 @@ _    :    =    =>    <-    <:    <%     >:    #    @
 The Unicode operators `\u21D2 $\Rightarrow$` and `\u2190 $\leftarrow$`, which have the ASCII
 equivalents `=>` and `<-`, are also reserved.
 
-###### Example: here are some identifiers:
+### Example:
 
 ```
     x         Object        maxIndex   p2p      empty_?
     +         `yield`       αρετη     _y       dot_product_*
     __system  _MAX_LEN_
 ```
 
-###### Example: backquote-enclosed strings
+### Example:
 When one needs to access Java identifiers that are reserved words in Scala, use backquote-enclosed strings.
 For instance, the statement `Thread.yield()` is illegal, since
 `yield` is a reserved word in Scala. However, here's a
@@ -207,7 +207,7 @@ A single new line token is accepted
 - in front of a [parameter clause](06-basic-declarations-and-definitions.html#function-declarations-and-definitions), and
 - after an [annotation](13-user-defined-annotations.html#user-defined-annotations).
 
-###### Example: four well-formed statements, each on two lines
+### Example:
 
 The newline tokens between the two lines are not
 treated as statement separators.
@@ -226,7 +226,7 @@ type
   IntList = List[Int]
 ```
 
-###### Example: an anonymous class
+### Example:
 
 ```
 new Iterator[Int]
@@ -250,7 +250,7 @@ new Iterator[Int]
 }
 ```
 
-###### Example: a single expression
+### Example:
 
 ```
   x < 0 ||
@@ -266,7 +266,7 @@ two expressions:
   x > 10
 ```
 
-###### Example: a single, curried function definition
+### Example:
 
 ```
 def func(x: Int)
@@ -282,7 +282,7 @@ def func(x: Int)
         (y: Int) = x + y
 ```
 
-###### Example: an attributed definition
+### Example:
 
 ```
 @serializable
@@ -356,7 +356,7 @@ is _pt_. The numeric ranges given by these types are:
 |`Char`          | $0$ to $2^{16}-1$      |
 
 
-###### Example: some integer literals
+### Example:
 
 ```
 0          21          0xFFFFFFFF       -42L
@@ -385,18 +385,18 @@ If a floating point literal in a program is followed by a token
 starting with a letter, there must be at least one intervening
 whitespace character between the two tokens.
 
-###### Example: some floating point literals
+### Example:
 
 ```
 0.0        1e30f      3.14159f      1.0e-100      .1
 ```
 
-###### Example: tokenizing
+### Example:
 
 The phrase `1.toString` parses as three different tokens:
 the integer literal `1`, a `.`, and the identifier `toString`.
 
-###### Example: invalid floating point literal
+### Example:
 
 `1.` is not a valid floating point literal because the mandatory digit after the `.` is missing.
 
@@ -420,7 +420,7 @@ A character literal is a single character enclosed in quotes.
 The character is either a printable unicode character or is described
 by an [escape sequence](#escape-sequences).
 
-###### Example: some character literals
+### Example:
 
 ```
 'a'    '\u0041'    '\n'    '\t'
@@ -447,7 +447,7 @@ contains a double quote character, it must be escaped,
 i.e. `"\""`. The value of a string literal is an instance of
 class `String`. 
 
-###### Example: some string literals
+### Example:
 
 ```
 "Hello,\nWorld!"
@@ -469,7 +469,7 @@ must not necessarily be printable; newlines or other
 control characters are also permitted.  Unicode escapes work as everywhere else, but none
 of the escape sequences [here](#escape-sequences) are interpreted.
 
-###### Example: a multi-line string literal:
+### Example:
 
 ```
   """the present string
@@ -600,7 +600,7 @@ The scanner switches from XML mode to Scala mode if either
 Note that no Scala tokens are constructed in XML mode, and that comments are interpreted
 as text.
 
-###### Example: XML literals
+### Example:
 
 The following value definition uses an XML literal with two embedded
 Scala expressions:

04-identifiers-names-and-scopes.md

@@ -1,6 +1,7 @@
 ---
 title: Identifiers, Names and Scopes
 layout: default
+chapter: 2
 ---
 
 # Identifiers, Names and Scopes
@@ -70,7 +71,7 @@ namespace as the identifier. It is an error if $T$ is not a [value type](05-type
 The type of $e.x$ is the member type of the referenced entity in $T$.
 
 
-###### Example: bindings
+### Example:
 
 Assume the following two definitions of a objects named `X` in packages `P` and `Q`.
 

05-types.md

@@ -1,6 +1,7 @@
 ---
 title: Types
 layout: default
+chapter: 3
 ---
 
 # Types
@@ -148,7 +149,7 @@ A qualified type designator has the form `p.t` where `p` is
 a [path](#paths) and _t_ is a type name. Such a type designator is
 equivalent to the type projection `p.type#t`.
 
-###### Example: fully qualified type designators
+### Example:
 
 Some type designators and their expansions are listed below. We assume
 a local type parameter $t$, a value `maintable`
@@ -181,7 +182,7 @@ well-formed if each actual type parameter
 _conforms to its bounds_, i.e. $\sigma L_i <: T_i <: \sigma U_i$ where $\sigma$ is the
 substitution $[ a_1 := T_1 , \ldots , a_n := T_n ]$.
 
-###### Example: parameterized types
+### Example:
 Given the partial type definitions:
 
 ```
@@ -205,7 +206,7 @@ F[List, Int]
 G[S, String]
 ```
 
-###### Example: ill-formed types
+### Example:
 
 Given the [above type definitions](example-parameterized-types),
 the following types are ill-formed:
@@ -261,7 +262,7 @@ An annotated type $T$ `$a_1 , \ldots , a_n$`
 attaches [annotations](13-user-defined-annotations.html#user-defined-annotations)
 $a_1 , \ldots , a_n$ to the type $T$.
 
-###### Example: annotated type
+### Example:
 
 The following type adds the `@suspendable` annotation to the type `String`:
 
@@ -309,7 +310,7 @@ A compound type may also consist of just a refinement
 `{ $R$ }` with no preceding component types. Such a type is
 equivalent to `AnyRef{ R }`.
 
-###### Example: structural refinement in a method's parameter type
+### Example:
 
 The following example shows how to declare and use a method which
 a parameter type that contains a refinement with structural declarations.
@@ -509,7 +510,7 @@ or [tuple types](#tuple-types).
 Their expansion is then the expansion in the equivalent parameterized
 type.
 
-###### Example: existential types
+### Example:
 
 Assume the class definitions
 
@@ -533,15 +534,15 @@ An alternative formulation of the first type above using wildcard syntax is:
 Ref[_ <: java.lang.Number]
 ```
 
-###### Example: abbreviating an existential type with the underscore
+### Example:
 
 The type `List[List[_]]` is equivalent to the existential type
 
 ```
 List[List[t] forSome { type t }] .
 ```
 
-###### Example: existential type equivalence
+### Example:
 
 Assume a covariant type
 
@@ -670,7 +671,7 @@ same name, we model
 
 An overloaded type consisting of type alternatives $T_1 \commadots T_n (n \geq 2)$ is denoted internally $T_1 \overload \ldots \overload T_n$.
 
-###### Example: The definitions
+### Example:
 ```
 def println: Unit
 def println(s: String): Unit = $\ldots$
@@ -688,7 +689,7 @@ println:  => Unit $\overload$
           [A] (A) (A => String) Unit
 ```
 
-###### Example: The definitions
+### Example:
 ```
 def f(x: T): T = $\ldots$
 val f = 0

06-basic-declarations-and-definitions.md

@@ -1,6 +1,7 @@
 ---
 title: Basic Declarations and Definitions
 layout: default
+chapter: 4
 ---
 
 # Basic Declarations and Definitions
@@ -573,7 +574,7 @@ abstract class Sequence[+A] {
 }
 ```
 
-###### Example: Here is a case where a contravariant type parameter is useful.
+### Example:
 
 ```
 abstract class OutputChannel[-A] {

07-classes-and-objects.md

@@ -1,6 +1,7 @@
 ---
 title: Classes and Objects
 layout: default
+chapter: 5
 ---
 
 # Classes and Objects
@@ -377,7 +378,7 @@ it is possible to add new defaults (if the corresponding parameter in the
 superclass does not have a default) or to override the defaults of the
 superclass (otherwise).
 
-###### Example: compound types
+### Example:
 
 Consider the definitions:
 
@@ -759,7 +760,7 @@ which when applied to parameters conforming to types $\mathit{ps}$
 initializes instances of type `$c$[$\mathit{tps}\,$]` by evaluating the template
 $t$.
 
-###### Example: private constructor
+### Example:
 The following example illustrates `val` and `var` parameters of a class `C`:
 
 ```
@@ -1009,7 +1010,7 @@ it is not statically known at the time the trait is defined.
 If $D$ is not a trait, then its actual supertype is simply its
 least proper supertype (which is statically known).
 
-###### Example: `Comparable`
+### Example:
 The following trait defines the property
 of being comparable to objects of some type. It contains an abstract
 method `<` and default implementations of the other

08-expressions.md

@@ -1,6 +1,7 @@
 ---
 title: Expressions
 layout: default
+chapter: 6
 ---
 
 # Expressions
@@ -209,7 +210,7 @@ to the type or method of $x$ in the parent trait of $C$ whose simple
 name is $T$. That member must be uniquely defined. If it is a method,
 it must be concrete.
 
-###### Example: `super`
+### Example:
 Consider the following class definitions
 
 ```
@@ -824,7 +825,7 @@ Here are some assignment expressions and their equivalent expansions.
 `x.f(i, j) = e`       x.f.update(i, j, e)
 --------------------------    ---------------------
 
-###### Example: imperative matrix multiplication
+### Example:
 
 Here is the usual imperative code for matrix multiplication.
 

09-implicit-parameters-and-views.md

@@ -1,6 +1,7 @@
 ---
 title: Implicit Parameters and Views
 layout: default
+chapter: 7
 ---
 
 # Implicit Parameters and Views
@@ -18,7 +19,7 @@ and can be used as implicit conversions called [views](#views).
 The `implicit` modifier is illegal for all
 type members, as well as for [top-level objects](11-top-level-definitions.html#packagings).
 
-###### Example: `Monoid`
+### Example:
 The following code defines an abstract class of monoids and
 two concrete implementations, `StringMonoid` and
 `IntMonoid`. The two implementations are marked implicit.
@@ -289,7 +290,7 @@ As for implicit parameters, overloading resolution is applied
 if there are several possible candidates (of either the call-by-value
 or the call-by-name category).
 
-###### Example: `Ordered`
+### Example:
 Class `scala.Ordered[A]` contains a method
 
 ```

10-pattern-matching.md

@@ -1,6 +1,7 @@
 ---
 title: Pattern Matching
 layout: default
+chapter: 8
 ---
 
 # Pattern Matching
@@ -596,7 +597,7 @@ the compilation of pattern matching can emit warnings which diagnose
 that a given set of patterns is not exhaustive, i.e. that there is a
 possibility of a `MatchError` being raised at run-time. 
 
-###### Example: `eval`
+### Example:
 
 Consider the following definitions of arithmetic terms:
 

11-top-level-definitions.md

@@ -1,6 +1,7 @@
 ---
 title: Top-Level Definitions
 layout: default
+chapter: 9
 ---
 
 # Top-Level Definitions

12-xml-expressions-and-patterns.md

@@ -1,6 +1,7 @@
 ---
 title: XML Expressions and Patterns
 layout: default
+chapter: 10
 ---
 
 # XML Expressions and Patterns