1 files changed, 96 insertions, 11 deletions

diff --git a/scala.html.markdown b/scala.html.markdown
index e82c1c36..78053b40 100644
--- a/scala.html.markdown
+++ b/scala.html.markdown
@@ -12,22 +12,62 @@ Scala - the scalable language
 
 ```scala
 
+/////////////////////////////////////////////////
+// 0. Basics
+/////////////////////////////////////////////////
 /*
-  Set yourself up:
+  Setup Scala:
 
   1) Download Scala - http://www.scala-lang.org/downloads
-  2) Unzip/untar to your favourite location and put the bin subdir in your `PATH` environment variable
-  3) Start a Scala REPL by running `scala`. You should see the prompt:
+  2) Unzip/untar to your favorite location and put the bin subdir in your `PATH` environment variable
+*/
 
-  scala>
+/*
+  Try the REPL
 
-  This is the so called REPL (Read-Eval-Print Loop). You may type any Scala
-  expression, and the result will be printed. We will explain what Scala files
-  look like further into this tutorial, but for now, let's start with some
-  basics.
+  Scala has a tool called the REPL (Read-Eval-Print Loop) that is analogous to
+  commandline interpreters in many other languages. You may type any Scala
+  expression, and the result will be evaluated and printed.  
 
+  The REPL is a very handy tool to test and verify code.  Use it as you read
+  this tutorial to quickly explore concepts on your own.
 */
 
+// Start a Scala REPL by running `scala`. You should see the prompt:
+$ scala
+scala>
+
+// By default each expression you type is saved as a new numbered value
+scala> 2 + 2
+res0: Int = 4
+
+// Default values can be reused.  Note the value type displayed in the result..
+scala> res0 + 2
+res1: Int = 6
+
+// Scala is a strongly typed language. You can use the REPL to check the type
+// without evaluating an expression.
+scala> :type (true, 2.0)
+(Boolean, Double)
+
+// REPL sessions can be saved
+scala> :save /sites/repl-test.scala
+
+// Files can be loaded into the REPL
+scala> :load /sites/repl-test.scala
+Loading /sites/repl-test.scala...
+res2: Int = 4
+res3: Int = 6
+
+// You can search your recent history
+scala> :h?
+1 2 + 2
+2 res0 + 2
+3 :save /sites/repl-test.scala
+4 :load /sites/repl-test.scala
+5 :h?
+
+// Now that you know how to play, let's learn a little scala...
 
 /////////////////////////////////////////////////
 // 1. Basics
@@ -48,7 +88,7 @@ println(10)
 // Printing, without forcing a new line on next print
 print("Hello world")
 print(10)
-// Hello world!10
+// Hello world10
 
 // Declaring values is done using either var or val.
 // val declarations are immutable, whereas vars are mutable. Immutability is
@@ -88,6 +128,7 @@ true == false // false
 6 / 2   // 3
 6 / 4   // 1
 6.0 / 4 // 1.5
+6 / 4.0 // 1.5
 
 
 // Evaluating an expression in the REPL gives you the type and value of the result
@@ -419,8 +460,52 @@ val otherGeorge = george.copy(phoneNumber = "9876")
 
 // And many others. Case classes also get pattern matching for free, see below.
 
+// Traits
+// Similar to Java interfaces, traits define an object type and method
+// signatures. Scala allows partial implementation of those methods.
+// Constructor parameters are not allowed. Traits can inherit from other
+// traits or classes without parameters.
+
+trait Dog {
+	def breed: String
+	def color: String
+	def bark: Boolean = true
+	def bite: Boolean
+}
+class SaintBernard extends Dog {
+	val breed = "Saint Bernard"
+	val color = "brown"
+	def bite = false
+}  
+
+scala> b  
+res0: SaintBernard = SaintBernard@3e57cd70  
+scala> b.breed  
+res1: String = Saint Bernard  
+scala> b.bark  
+res2: Boolean = true  
+scala> b.bite  
+res3: Boolean = false  
+
+// A trait can also be used as Mixin. The class "extends" the first trait,
+// but the keyword "with" can add additional traits.
+
+trait Bark {
+	def bark: String = "Woof"
+}
+trait Dog {
+	def breed: String
+	def color: String
+}
+class SaintBernard extends Dog with Bark {
+	val breed = "Saint Bernard"
+	val color = "brown"
+}
 
-// Traits coming soon!
+scala> val b = new SaintBernard
+b: SaintBernard = SaintBernard@7b69c6ba
+scala> b.bark
+res0: String = Woof
 
 
 /////////////////////////////////////////////////
@@ -553,7 +638,7 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
  * best practices around them. We only include this section in the tutorial
  * because they are so commonplace in Scala libraries that it is impossible to
  * do anything meaningful without using a library that has implicits. This is
- * meant for you to understand and work with implicts, not declare your own.
+ * meant for you to understand and work with implicits, not declare your own.
  */
 
 // Any value (vals, functions, objects, etc) can be declared to be implicit by