Review Taste of Scala

Author: adpi2

_overviews/scala3-book/taste-collections.md

@@ -9,7 +9,7 @@ next-page: taste-contextual-abstractions
 
 
 
-Scala has a rich set of collections classes, and those classes have a rich set of methods.
+The Scala library has a rich set of collection classes, and those classes have a rich set of methods.
 Collections classes are available in both immutable and mutable forms.
 
 
@@ -98,7 +98,7 @@ t._2   // "eleven"
 t._3   // Person("Eleven")
 ```
 
-You can also use this *extractor* approach to assign the tuple fields to variable names:
+You can also use this _extractor_ approach to assign the tuple fields to variable names:
 
 ```scala
 val (num, str, person) = t

_overviews/scala3-book/taste-contextual-abstractions.md

@@ -12,19 +12,43 @@ next-page: taste-toplevel-definitions
 TODO: Now that this is a separate section, it needs a little more content.
 {% endcomment %}
 
+Under certain circumstances, you can omit some parameters of method calls that are considered repetitive.
 
-Under certain circumstances, the Scala compiler can “write” some parts of your programs.
-For instance, consider a program that sorts a list of addresses by two criteria, city name and then street name:
+Those parameters are called _Context Parameters_ because they are inferred by the compiler from the context surrounding the method call.
+
+For instance, consider a program that sorts a list of addresses by two criteria: the city name and then street name.
 
 ```scala
 val addresses: List[Address] = ...
+
 addresses.sortBy(address => (address.city, address.street))
 ```
 
-The sorting algorithm needs to compare addresses by first comparing their city names, and then also their street names when the city names are the same.
-However, with the use of contextual abstraction, you don’t need to manually define this ordering relation, because the compiler is able to summon it automatically based on an existing ordering relation for comparing string values.
+The `sortBy` method takes a function that returns, for every address, the value to compare it with the other addresses.
+In this case, we pass a function that returns a pair containing the city name and the street name.
+
+Note that we only indicate _what_ to compare, but not _how_ to perform the comparison.
+How does the sorting algorithm know how to compare pairs of `String`?
+
+Actually, the `sortBy` method takes a second parameter---a context parameter---that is inferred by the compiler.
+It does not appear in the above example because it is supplied by the compiler.
+
+This second parameter implements the _how_ to compare.
+It is convenient to omit it because we know `String`s are generally compared using the lexicographic order.
+
+However, it is also possible to pass it explicitly:
+
+```scala
+addresses.sortBy(address => (address.city, address.street))(using Ordering.Tuple2(Ordering.String, Ordering.String))
+```
+
+In this case, the `Ordering.Tuple2(Ordering.String, Ordering.String)` instance is exactly the one that is otherwise inferred by the compiler.
+In other words both examples produce the same program.
+
+_Contextual Abstractions_ is used to avoid repetition of code.
+It helps developers write pieces of code that are extensible and concise at the same time.
 
-For more details, see the [Contextual Abstractions chapter][contextual] of this book, and also in the [Reference documentation][reference].
+For more details, see the [Contextual Abstractions chapter][contextual] of this book, and also the [Reference documentation][reference].
 
 
 

_overviews/scala3-book/taste-control-structures.md

@@ -136,7 +136,7 @@ yield
   // of code here
   f.length
 
-// result: List[Int] = List(5, 6, 6)
+// fruitLengths: List[Int] = List(5, 6, 6)
 ```
 
 `for` loops and expressions are covered in more detail in the [Control Structures sections][control] of this book, and in the [Reference documentation]({{ site.scala3ref }}/other-new-features/control-syntax.html).

_overviews/scala3-book/taste-functions.md

@@ -13,17 +13,20 @@ Scala has most features you’d expect in a functional programming language, inc
 
 - Lambdas
 - Higher-order functions (HOFs)
-- Higher-order functions in the standard library
+- Immutable collections in the standard library
 
 Lambdas, also known as _anonymous functions_, are a big part of keeping your code concise but readable.
-These two examples---which show how to call higher-order functions (HOFs) on a Scala `List`---are equivalent, and show how to multiply each number in a list by `2` by passing a lambda into the `map` method:
+
+The `map` method of the `List` class is a typical example of a higher-order function---a function that takes a lambda as parameter.
+
+These two examples are equivalent, and show how to multiply each number in a list by `2` by passing a lambda into the `map` method:
 
 ```scala
 val a = List(1, 2, 3).map(i => i * 2)   // List(2,4,6)
 val b = List(1, 2, 3).map(_ * 2)        // List(2,4,6)
 ```
 
-Those examples are also equivalent to the following code, which uses a `double` method inside of `map` instead of a lambda:
+Those examples are also equivalent to the following code, which uses a `double` method instead of a lambda:
 
 ```scala
 def double(i: Int): Int = i * 2

_overviews/scala3-book/taste-methods.md

@@ -11,15 +11,15 @@ next-page: taste-functions
 ## Scala methods
 
 Scala classes, case classes, traits, enums, and objects can all contain methods.
-When a method isn’t declared to use a generic type or accept `using` parameters, its general syntax looks like this:
+The syntax of a simple method looks like this:
 
 ```scala
 def methodName(param1: Type1, param2: Type2): ReturnType =
   // the method body
   // goes here
 ```
 
-Here are a few examples of that syntax:
+Here are a few examples:
 
 ```scala
 def sum(a: Int, b: Int): Int = a + b
@@ -50,7 +50,7 @@ def getStackTraceAsString(t: Throwable): String =
 ```
 
 Method parameters can also have default values.
-In this example, if the `timeout` parameter isn’t specified, it defaults to `5000`:
+In this example, the `timeout` parameter has a default value of `5000`:
 
 ```scala
 def makeConnection(url: String, timeout: Int = 5000): Unit =
@@ -100,15 +100,15 @@ For instance, if you want to add two methods named `hello` and `aloha` to the `S
 
 ```scala
 extension (s: String)
-  def hello: String = s"Hello, ${s.capitalize}"
-  def aloha: String = s"Aloha, ${s.capitalize}"
+  def hello: String = s"Hello, ${s.capitalize}!"
+  def aloha: String = s"Aloha, ${s.capitalize}!"
 
-"world".hello    // "Hello, World"
-"friend".aloha   // "Aloha, Friend"
+"world".hello    // "Hello, World!"
+"friend".aloha   // "Aloha, Friend!"
 ```
 
-The `extension` keyword declares that you’re about to define one or more extension methods on the type that’s put in parentheses.
-As shown with this `String` example, the parameter `s` can then be used in the body of your extension methods.
+The `extension` keyword declares that you’re about to define one or more extension methods on the parameter that’s put in parentheses.
+As shown with this example, the parameter `s` of type `String` can then be used in the body of your extension methods.
 
 This next example shows how to add a `makeInt` method to the `String` class.
 Here, `makeInt` takes a parameter named `radix`.
@@ -127,7 +127,8 @@ extension (s: String)
 
 ## See also
 
-Methods are covered in detail in the [Data Modeling][data-1] section.
+Scala Methods can be much more powerful: they can take type parameters and context parameters.
+They are covered in detail in the [Data Modeling][data-1] section.
 
 
 

_overviews/scala3-book/taste-modeling.md

@@ -76,10 +76,10 @@ These examples show how those classes are used:
 
 ```scala
 val d = Dog("Rover")
-d.speak()               // prints "Woof!"
+println(d.speak())      // prints "Woof!"
 
 val c = Cat("Morris")
-c.speak()               // "Meow"
+println(c.speak())      // "Meow"
 c.startRunning()        // "Yeah ... I don’t run"
 c.stopRunning()         // "No need to stop"
 ```

_overviews/scala3-book/taste-objects.md

@@ -88,8 +88,8 @@ println(multiply(2,2))   // 4
 {% comment %}
 NOTE: I don’t know if this is worth keeping, but I’m leaving it here as a comment for now.
 
-> You may read that objects are used to *reify* traits into modules.
-> *Reify* means, “to take an abstract concept and turn it into something concrete.” This is what happens in these examples, but “implement” is a more familiar word for most people than “reify.”
+> You may read that objects are used to _reify_ traits into modules.
+> _Reify_ means, “to take an abstract concept and turn it into something concrete.” This is what happens in these examples, but “implement” is a more familiar word for most people than “reify.”
 {% endcomment %}
 
 

_overviews/scala3-book/taste-toplevel-definitions.md

@@ -9,7 +9,7 @@ next-page: taste-summary
 
 
 In Scala 3, all kinds of definitions can be written at the “top level” of your source code files.
-For instance, you can create a file named *MyCoolApp.scala* and put these contents into it:
+For instance, you can create a file named _MyCoolApp.scala_ and put these contents into it:
 
 ```scala
 import scala.collection.mutable.ArrayBuffer
@@ -42,8 +42,8 @@ As shown, there’s no need to put those definitions inside a `package`, `class`
 
 ## Replaces package objects
 
-If you’re familiar with Scala 2, this approach replaces *package objects*.
-But while being much easier to use, they work similarly: When you place a definition in a package named *foo*, you can then access that definition under all other packages under *foo*, such as within the *foo.bar* package in this example:
+If you’re familiar with Scala 2, this approach replaces _package objects_.
+But while being much easier to use, they work similarly: When you place a definition in a package named _foo_, you can then access that definition under all other packages under _foo_, such as within the _foo.bar_ package in this example:
 
 ```scala
 package foo {
@@ -60,6 +60,6 @@ package foo {
 
 Curly braces are used in this example to put an emphasis on the package nesting.
 
-The benefit of this approach is that you can place definitions under a package named *com.acme.myapp*, and then those definitions can be referenced within *com.acme.myapp.model*, *com.acme.myapp.controller*, etc.
+The benefit of this approach is that you can place definitions under a package named _com.acme.myapp_, and then those definitions can be referenced within _com.acme.myapp.model_, _com.acme.myapp.controller_, etc.