Revisited Scala Change History

Since version 2.0 of March 2006 the Scala compiler is completely written in Scala itself.

Examples

1. Language features producing a compiler warning (since 2.10.x) [↑]

   // File features.scala
   class WrappedString(s: String) { def foo = s }
   
   object features extends App {
     implicit def wrappedString(s: String) = new WrapperString(s)
     println("abc" foo)
   }
   

   $ scalac -d /tmp features.scala 
   warning: there were 2 feature warnings; re-run with -feature for details
   two warnings found
   

   Let's use the compiler option -feature to display the warning details.

   $ scalac -feature -d /tmp features.scala
   features.scala:5: warning: implicit conversion method wrappedString should be enabled
   by making the implicit value language.implicitConversions visible.
   This can be achieved by adding the import clause 'import language.implicitConversions'
   or by setting the compiler option -language:implicitConversions.
   See the Scala docs for value scala.language.implicitConversions for a discussion
   why the feature should be explicitly enabled.
     implicit def wrappedString(s: String) = new WrappedString(s)
                  ^
   features.scala:6: warning: postfix operator foo should be enabled
   by making the implicit value language.postfixOps visible.
   This can be achieved by adding the import clause 'import language.postfixOps'
   or by setting the compiler option -language:postfixOps.
   See the Scala docs for value scala.language.postfixOps for a discussion
   why the feature should be explicitly enabled.
     println(new A() foo)
                     ^
   two warnings found
   

2. Pattern definitions [↑]

   // File patdef.scala
   object patdef extends Application {
     var (x, y) = if (math.random < 0.5) (1, 2) else (-1, -3)
     var hd :: tl = List(1, 2, 3)
     y *= 2
     hd += 1
     println(y)  // prints either "4" or "-6"
     println(hd) // prints "2"
   }

3. Structural types [↑]

   // File structs.scala
   class File(name: String) {
     def getName(): String = name
     def open() { /*..*/ }
     def close() { println("close file") }
   }
   object structs extends Application {
     def test(f: { def getName(): String }) { println(f.getName) }
   
     test(new File("test.txt"))
     test(new java.io.File("test.txt"))
   }

4. Type constructor polymorphism [↑]

   trait Iterable[+T] {
     type MyType[+T] <: Iterable[T] // MyType is a type constructor
                   
     def filter(p: T => Boolean): MyType[T] = //...
     def map[S](f: T => S): MyType[S] = //...
   }
   
   abstract class List[+T] extends Iterable[T] {
     type MyType[+T] = List[T]
   }

5. Tuples with arity 2 up to 22 [↑]

   // File tuples.scala
   import TupleOps._
   object tuples extends Application {
     val pairs = List(
       Pair(1015, "Lausanne"), // old style
       (1220, "Genève"),
       1950 -> "Sion" // "->" defined in object Predef
     )
     val buf = new collection.mutable.ListBuffer[(Int, String)]
     buf += Pair(1015, "Lausanne")
     buf += ((1220, "Genève")) // outer parenthese required!
     buf += 1950 -> "Sion"
     assert(pairs == buf.toList)
     val triples = List(
       Triple(1700, "Fribourg", "026"),
       (2000, "Neuchâtel", "032"),
       2500 -> "Bienne" --> "032" // "-->" defined in object TupleOps
     )
   }

   For convenience pairs in Scala can be created with the predefined method -> (see object scala.Predef). Below we define our own method --> to support the creation of triples.

   // File TupleOps.scala
   object TupleOps {
     // see scala.Predef.any2ArrowAssoc
     final class ArrowAssoc[T1, T2](val x: Tuple2[T1, T2]) {
       @inline def --> [T3](y: T3) = Tuple3(x._1, x._2, y)
     }
     implicit def pair2ArrowAssoc[T1, T2](x: Tuple2[T1, T2]) =
       new ArrowAssoc(x)
     // more implicits
   }

6. Extractor objects [↑]

   // File extractors.scala
   object Twice {
     def apply(x: Int): Int = x * 2
     def unapply(z: Int): Option[Int] =
       if (z % 2 == 0) Some(z / 2) else None
   }
   object extractors extends Application {
     val x = Twice(21) 
     x match { case Twice(n) => println(n) } // prints 21
   }

References

1. The Scala Language Specification (SLS), Version 2.8
   Martin Odersky, November 2010
   LAMP/EPFL

About the Author

Stéphane Micheloud is a senior software engineer. He holds a Ph.D in computer science from EPFL and a M.Sc in computer science from ETHZ. At EPFL he worked on distributed programming and advanced compiler techniques and participated for over six years to the Scala project. Previously he was professor in computer science at HES-SO // Valais in Sierre, Switzerland.

[Top]

---

Other Articles

• Fast track to Scala (July 2009).
• Scala versus Java (July 2009).
• Scala Common Pitfalls (August 2009).
• Using Scala Code from Java (August 2009).
• Functional Programming in Scala (November 2010).
• Scala Advanced Features (November 2010).
• Towards Scala Certifications (January 2011).
• XML-free Scala (September 2011).
• Tailoring the Scala Library (October 2011).
• Using Scala Reflection (December 2011).

[Top]

---

Last updated: November 27, 2010.

HTML5 CSS2.1