Merge branch 'master' of github.com:scala/scala.github.com

heathermiller · heathermiller · commit e30272bb6b5e · 2012-05-31T00:31:29.000+02:00
diff --git a/es/overviews/core/actors.md b/es/overviews/core/actors.md
diff --git a/style/control-structures.md b/style/control-structures.md
@@ -39,6 +39,8 @@ Remember the following guidelines:
     Otherwise, use curly braces for clarity (even though they are not
     *required* by the parser).
 
+<!-- necessary to separate the following example from the above bullet list --> 
+
     val news = if (foo)
       goodNews()
     else
diff --git a/style/declarations.md b/style/declarations.md
@@ -100,14 +100,14 @@ applicable):
 4.  Final modifier (`final`)
 5.  `def`
 
-```scala
-@Transaction
-@throws(classOf[IOException])
-override protected final def foo() { 
-  ...
-}
-```
+<!-- necessary to separate the following example from the above bullet list --> 
 
+    @Transaction
+    @throws(classOf[IOException])
+    override protected final def foo() { 
+      ...
+    }
+    
 #### Body
 
 When a method body comprises a single expression which is less than 30
@@ -171,7 +171,7 @@ There are three main reasons you should do this:
     Multiple parameter lists allow you to create your own "control
     structures":
 
-        def unless(exp:Boolean)(code: => Unit) = if (!exp) code
+        def unless(exp: Boolean)(code: => Unit) = if (!exp) code
         unless(x < 5) { 
           println("x was not less than five")
         }
@@ -188,7 +188,7 @@ There are three main reasons you should do this:
     type inferencer can allow a simpler syntax when invoking the
     remaining parameter lists. Consider fold:
 
-        def foldLeft[B](z:B)(op: (A,B) => B): B
+        def foldLeft[B](z: B)(op: (A,B) => B): B
         List("").foldLeft(0)(_ + _.length)
 
         // If, instead:
diff --git a/style/naming-conventions.md b/style/naming-conventions.md
@@ -97,7 +97,7 @@ mutator and accessor methods (respectively). Instead, the following
 conventions are used:
 
 -   For accessors of properties, the name of the method should be the
-    name of the property
+    name of the property.
 -   In some instances, it is acceptable to prepend "\`is\`" on a boolean
     accessor (e.g. `isEmpty`). This should only be the case when no
     corresponding mutator is provided. Please note that the
@@ -111,21 +111,21 @@ conventions are used:
     mirrors assignment. Note that this is not just a convention but a
     requirement of the language.
 
-    class Foo {
-    
-      def bar = ...
-    
-      def bar_=(bar: Bar) {
-        ...
-      }
-
-      def isBaz = ...
-    }
+        class Foo {
+        
+          def bar = ...
+        
+          def bar_=(bar: Bar) {
+            ...
+          }
+        
+          def isBaz = ...
+        }
 
-    val foo = new Foo
-    foo.bar             // accessor
-    foo.bar = bar2      // mutator
-    foo.isBaz           // boolean property
+        val foo = new Foo
+        foo.bar             // accessor
+        foo.bar = bar2      // mutator
+        foo.isBaz           // boolean property
 
 
 Quite unfortunately, these conventions fall afoul of the Java convention
@@ -173,8 +173,7 @@ use an immutable reference to a property class that contains its own
 getter and setter. For example:
 
     class Company {
-      val string : Property[String] = 
-            Property("Initial Value")
+      val string: Property[String] = Property("Initial Value")
 
 ### Parentheses
 
@@ -273,23 +272,23 @@ should be used, following the class naming conventions (as opposed to an
 all-uppercase style):
 
     // Right
-    class Map[Key,Value] {
-      def get(key:Key): Value
-      def put(key:Key,value:Value): Unit
+    class Map[Key, Value] {
+      def get(key: Key): Value
+      def put(key: Key, value: Value): Unit
     }
 
     // Wrong; don't use all-caps
-    class Map[KEY,VALUE] {
-      def get(key:KEY): VALUE
-      def put(key:KEY,value:VALUE): Unit
+    class Map[KEY, VALUE] {
+      def get(key: KEY): VALUE
+      def put(key: KEY, value: VALUE): Unit
     }
 
 If the scope of the type parameter is small enough, a mnemonic can be
 used in place of a longer, descriptive name:
 
-    class Map[K,V] {
-      def get(key:K): V
-      def put(key:K,value:V): Unit
+    class Map[K, V] {
+      def get(key: K): V
+      def put(key: K, value: V): Unit
     }
 
 ### Higher-Kinds and Parameterized Type parameters
diff --git a/style/scaladoc.md b/style/scaladoc.md
@@ -40,7 +40,7 @@ customary in Java.
 
 See the
 [AuthorDocs](https://wiki.scala-lang.org/display/SW/Writing+Documentation)
-on the Scala wiki for more technical info on formatting ScalaDoc
+on the Scala wiki for more technical info on formatting ScalaDoc.
 
 ## General Style
 
@@ -99,8 +99,8 @@ that package. Be sure to reference classes using the square-bracket
 notation:
 
     package my.package
-    /** Provides classes for dealing with complex numbers.  Also provides implicits for
-      * converting to and from `Int`.
+    /** Provides classes for dealing with complex numbers.  Also provides
+      * implicits for converting to and from `Int`.
       *
       * ==Overview==
       * The main class to use is [[my.package.complex.Complex]], as so
@@ -143,7 +143,7 @@ the `@constructor` syntax:
       * @param name the person's name
       * @param age the person's age in years 
       */
-    class Person(name:String, age:Int) {
+    class Person(name: String, age: Int) {
     }
 
 Depending on the complexity of your class, provide an example of common
@@ -165,15 +165,16 @@ sure to indicate the actual method names:
         * @param name their name
         * @param age the age of the person to create 
         */
-      def apply(name:String,age:Int) = {}
+      def apply(name: String, age: Int) = {}
+
       /** Create a person with a given name and birthdate
         *
         * @param name their name
         * @param birthDate the person's birthdate
         * @return a new Person instance with the age determined by the 
         *         birthdate and current date. 
         */
-      def apply(name:String,birthDate:java.util.Date) = {}
+      def apply(name: String, birthDate: java.util.Date) = {}
     }
 
 If your object holds implicit conversions, provide an example in the
@@ -183,7 +184,7 @@ ScalaDoc:
       *
       * {{ "{{{" }}
       * import ComplexImplicits._
-      * val c:Complex = 4 + 3.i
+      * val c: Complex = 4 + 3.i
       * }}} 
       */
     object ComplexImplicits {}
diff --git a/tutorials/tour/default-parameter-values.md b/tutorials/tour/default-parameter-values.md
@@ -61,5 +61,5 @@ Scala adds direct support for this:
     // named arguments
     val m4 = new HashMap[String,Int](loadFactor = 0.8)
 
-Note how we can take advantage of *any* default value by using [named parameters]({{ site.baseurl }}/tutorials/tour/named_parameters.html).
+Note how we can take advantage of *any* default value by using [named parameters]({{ site.baseurl }}/tutorials/tour/named-parameters.html).
 
diff --git a/tutorials/tour/named-parameters.md b/tutorials/tour/named-parameters.md
@@ -22,7 +22,7 @@ When calling methods and functions, you can use the name of the variables explic
       // Prints "John Smith"
 
 Note that once you are using parameter names in your calls, the order doesn't matter, so long as all parameters are named.  This
-feature works well with [default parameter values]({{ site.baseurl }}/tutorials/tour/default_parameter_values.html):
+feature works well with [default parameter values]({{ site.baseurl }}/tutorials/tour/default-parameter-values.html):
 
       def printName(first:String = "John", last:String = "Smith") = {
         println(first + " " + last)
