Merge branch 'master' into brings-new-pgp-keys

Author: juanpedromoreno

src/main/scala/stdlib/ByNameParameter.scala

@@ -11,7 +11,7 @@ object ByNameParameter extends FlatSpec with Matchers with org.scalaexercises.de
   def takesUnitByNameParameter(res0: Either[Throwable, Int]) {
     def calc(x: () ⇒ Int): Either[Throwable, Int] = {
       try {
-        Right(x()) //An explicit call the x function
+        Right(x()) //An explicit call of the x function
       } catch {
         case b: Throwable ⇒ Left(b)
       }

src/main/scala/stdlib/CaseClasses.scala

@@ -29,7 +29,7 @@ object CaseClasses extends FlatSpec with Matchers with org.scalaexercises.defini
     *
     * {{{
     * val x = Var("x")
-    * Console.println(x.name)
+    * println(x.name)
     * }}}
     *
     * For every case class the Scala compiler generates `equals` method which implements structural equality and a`toString` method. For instance:
@@ -61,7 +61,7 @@ object CaseClasses extends FlatSpec with Matchers with org.scalaexercises.defini
     * print("^" + x + ".")
     * printTerm(b)
     * case App(f, v) =>
-    * Console.print("(")
+    * print("(")
     * printTerm(f)
     * print(" ")
     * printTerm(v)

src/main/scala/stdlib/Classes.scala

@@ -31,6 +31,8 @@ object Classes extends FlatSpec with Matchers with org.scalaexercises.definition
     *
     * 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`.
     *
+    * This also demonstrates the use of a value parameters in ClassWithValParameter(val name: String), which automatically creates an internal property (val name: String) in the class.
+    *
     */
   def classWithValParameterClasses(res0: String) {
     class ClassWithValParameter(val name: String)

src/main/scala/stdlib/TypeVariance.scala

@@ -99,25 +99,26 @@ object TypeVariance extends FlatSpec with Matchers with org.scalaexercises.defin
   }
 
   /** Declaring - indicates contravariance variance.  Using - you can apply any container with a certain type to a container with a superclass of that type.  This is reverse to covariant.  In our example, we can set a citrus basket to an orange or tangelo basket. Since an orange or tangelo basket are a citrus basket. Contravariance is the opposite of covariance:
-    * //TODO rework without mutability
-    *
-    * def contravarianceVarianceTypeVariance(res0: String, res1: String, res2: String, res3: String) {
-    * class MyContainer[-A](val a: A)(implicit manifest: scala.reflect.Manifest[A]) {
-    * def contents = manifest.runtimeClass.getSimpleName
-    * }
-    *
-    * val citrusBasket: MyContainer[Citrus] = new MyContainer[Citrus](new Orange)
-    * citrusBasket.contents should be(res0)
-    * val orangeBasket: MyContainer[Orange] = new MyContainer[Citrus](new Tangelo)
-    * orangeBasket.contents should be(res1)
-    * val tangeloBasket: MyContainer[Tangelo] = new MyContainer[Citrus](new Orange)
-    * tangeloBasket.contents should be(res2)
-    *
-    * val orangeBasketReally: MyContainer[Orange] = tangeloBasket.asInstanceOf[MyContainer[Orange]]
-    * orangeBasketReally.contents should be(res3)
-    * }
     */
 
+  def contravarianceVarianceTypeVariance(res0: String, res1: String, res2: String, res3: String) {
+    class MyContainer[-A](a: A)(implicit manifest: scala.reflect.Manifest[A]) { //Can't receive a val because it would be in a covariant position
+       def contents = manifest.runtimeClass.getSimpleName
+    }
+
+    val citrusBasket: MyContainer[Citrus] = new MyContainer[Citrus](new Orange)
+    citrusBasket.contents should be(res0)
+    val orangeBasket: MyContainer[Orange] = new MyContainer[Citrus](new Tangelo)
+    orangeBasket.contents should be(res1)
+    val tangeloBasket: MyContainer[Tangelo] = new MyContainer[Citrus](new Orange)
+    tangeloBasket.contents should be(res2)
+    val bananaBasket: MyContainer[Banana] = new MyContainer[Fruit](new Apple)
+    bananaBasket.contents should be(res3)
+
+    //val fruitBasket: MyContainer[Fruit] = new MyContainer[Citrus](new Orange) //Bad!
+    //val wrongCitrusBasket: MyContainer[Citrus] = new MyContainer[Orange](new Orange) //Bad!
+  }
+
   /** Declaring neither `-`/`+`, indicates invariance variance. You cannot use a superclass variable reference (\"contravariant\" position) or a subclass variable reference (\"covariant\" position) of that type.  In our example, this means that if you create a citrus basket you can only reference that citrus basket with a citrus variable only.
     *
     * Invariance means you need to specify the type exactly:

src/test/scala/stdlib/TypeVarianceSpec.scala

@@ -52,6 +52,15 @@ class TypeVarianceSpec extends Spec with Checkers {
     )
   }
 
+  def `contravariance` = {
+    check(
+      Test.testSuccess(
+        TypeVariance.contravarianceVarianceTypeVariance _,
+        "Citrus" :: "Citrus" :: "Citrus" :: "Fruit" :: HNil
+      )
+    )
+  }
+
   def `invariance` = {
     check(
       Test.testSuccess(