Initial merge of Julien's suggestions.

Author: alvinj

_overviews/overview/a-taste-of-scala.md

@@ -239,19 +239,21 @@ val mi = 'C'
 val lastName = "Doe"
 ```
 
-String interpolation lets you combine those variables in a string like this:
+You can combine those variables in a string like this:
 
 ```scala
 println(s"Name: $firstName $mi $lastName")   // "Name: John C Doe"
 ```
 
 Just precede the string with the letter `s`, and then put a `$` symbol before your variable names inside the string.
 
-For expressions more complex than a single identifier, enclose the expression in curly braces:
+To enclose expressions inside a string, enclose them in curly braces:
 
-```scala
+~~~ scala
 println(s"2 + 2 = ${2 + 2}")   // prints "2 + 2 = 4"
-```
+val x = -1
+println(s"x.abs = ${x.abs}")   // prints "x.abs = 1"
+~~~
 
 #### Other interpolators
 
@@ -347,7 +349,7 @@ else
 Note that this really is an *expression* — not a *statement* — meaning that it returns a value, so you can assign the result to a variable:
 
 ```scala
-val x = if (a < b) a else b
+val x = if a < b then a else b
 ```
 
 As you’ll see throughout this Overview and in our Reference documentation, *all* Scala control structures can be used as expressions.
@@ -369,7 +371,7 @@ The `for` keyword can be used to create a `for` loop. This example shows how to
 ```scala
 val ints = List(1,2,3,4,5)
 
-for (i <- ints) println(i)
+for i <- ints do println(i)
 ```
 
 <!--
@@ -410,15 +412,14 @@ We encourage you to make changes to that code to be sure you understand how it w
 
 #### Using `for` as an expression
 
-The `for` keyword has even more power: When you add the `yield` keyword to `for` loops, you create powerful `for` *expressions* which are used to calculate and yield results.
+The `for` keyword has even more power: When you use the `yield` keyword instead of `do`, you create `for` *expressions* which are used to calculate and yield results.
 
 A few examples demonstrate this. Using the same `ints` list as the previous example, this code creates a new list, where the value of each element in the new list is twice the value of the elements in the original list:
 
 ````
 scala> val doubles = for (i <- ints) yield i * 2
 val doubles: List[Int] = List(2, 4, 6, 8, 10)
 ````
-
 Note that Scala’s syntax is flexible, and that `for` expression can be written in several different ways to make your code more readable:
 
 ```scala
@@ -591,7 +592,7 @@ trait Runner:
 Given those traits, here’s a `Dog` class that extends all of those traits while providing a behavior for the abstract `speak` method:
 
 ```scala
-class Dog(name: String) extends Speaker with TailWagger with Runner:
+class Dog(name: String) extends Speaker, TailWagger, Runner:
   def speak(): String = "Woof!"
 ```
 
@@ -600,7 +601,7 @@ Notice how the class extends the traits with the `extends` and `with` keywords.
 Similarly, here’s a `Cat` class that implements those same traits while also overriding two of the concrete methods it inherits:
 
 ```scala
-class Cat(name: String) extends Speaker with TailWagger with Runner:
+class Cat(name: String) extends Speaker, TailWagger, Runner:
   def speak(): String = "Meow"
   override def startRunning(): Unit = println("Yeah ... I don’t run")
   override def stopRunning(): Unit = println("No need to stop")
@@ -652,7 +653,7 @@ p.printFullName()      // "Julia Manes"
 ```
 
 
-### FP data modeling 
+### Data Modeling (Functional Programming Style)
 
 When writing code in an FP style, you’ll use these constructs:
 
@@ -754,7 +755,7 @@ val p = Person("Reginald Kenneth Dwight", "Singer")
 // a good default toString method
 p                // Person = Person(Reginald Kenneth Dwight,Singer)
 
-// can access its fields, but they are immutable
+// can access its fields, which are immutable
 p.name           // "Reginald Kenneth Dwight"
 p.name = "Joe"   // error: can’t reassign a val field
 
@@ -1313,11 +1314,3 @@ Scala has even more features that weren’t covered in this whirlwind tour. See
 
 
 
-
-
-
-
-
-
-
-