Responding to more comments

Author: alvinj

Diff for: _overviews/scala3-book/collections-methods.md

@@ -51,9 +51,9 @@ a.takeRight(2)                        // List(40, 10)
 ```
 
 
-### Lambdas and HOFs
+### Higher-order functions and lambdas
 
-Next, we’ll show some commonly used higher-order functions (HOFs) that accept _lambda_ methods. To get started, here are several variations of the lambda syntax, starting with the longest form, working in steps towards the most concise form:
+Next, we’ll show some commonly used higher-order functions (HOFs) that accept lambdas (anonymous functions). To get started, here are several variations of the lambda syntax, starting with the longest form, working in steps towards the most concise form:
 
 ```scala
 // these functions are all equivalent and return
@@ -171,6 +171,19 @@ scala> val shortNames = names.filter(_.length <= 4)
 shortNames: List[String] = List(adam)
 ```
 
+A great thing about the functional methods on collections is that you can chain them together to solve problems. For instance, this example shows how to chain `filter` and `map`:
+
+```scala
+oneToTen.filter(_ < 4).map(_ * 10)
+```
+
+The REPL shows the result:
+
+```scala
+scala> oneToTen.filter(_ < 4).map(_ * 10)
+val res1: List[Int] = List(10, 20, 30)
+```
+
 
 
 ## `foreach`
@@ -185,21 +198,6 @@ chris
 david
 ```
 
-A great thing about the functional methods on the collections is that you can chain them together to solve problems. For example, this is one way to print the first three elements from `oneToTen`:
-
-```scala
-oneToTen.filter(_ < 4).foreach(println)
-```
-
-The REPL shows the result:
-
-```scala
-scala> oneToTen.filter(_ < 4).foreach(println)
-1
-2
-3
-```
-
 
 
 ## `head`

Diff for: _overviews/scala3-book/domain-modeling-fp.md

@@ -14,6 +14,9 @@ This chapter provides an introduction to domain modeling using functional progra
 - Case classes
 - Traits
 
+>If you’re not familiar with algebraic data types (ADTs) and their generalized version (GADTs), you may want to read the [Algebraic Data Types][adts] section before reading this section.
+
+
 
 ## Introduction
 
@@ -156,7 +159,7 @@ def crustPrice(s: CrustSize, t: CrustType): Double =
     case (Large, Regular) => 0.75
     case (Large, Thick) => 1.00
 ```
-To compute the price of the crust we simultanously pattern match on both the size and the type of the crust.
+To compute the price of the crust we simultaneously pattern match on both the size and the type of the crust.
 
 > An important point about all functions shown above is that they are *pure functions*: they do not mutate any data or have other side-effects (like throwing exceptions or writing to a file). All they do is simply receive values and compute the result.
 
@@ -174,7 +177,11 @@ These different solutions are shown in the remainder of this section.
 
 ### Companion Object
 
-A first approach is to define the behavior — the functions — in a companion object. With this approach, in addition to the enumeration or case class you also define an equally named companion object that contains the behavior.
+A first approach is to define the behavior — the functions — in a companion object.
+
+>As discussed in the Domain Modeling [Tools section][modeling-tools], a _companion object_ is an `object` that has the same name as a class, and is declared in the same file as the class.
+
+With this approach, in addition to the enumeration or case class you also define an equally named companion object that contains the behavior.
 
 ```scala
 case class Pizza(
@@ -410,3 +417,7 @@ Then, to model the behavior define functions that operate on values of your data
 - You can use a modular programming style, separating interface and implementation
 - You can use a “functional objects” approach and store the methods on the defined data type
 - You can use extension methods to equip your data model with functionality
+
+
+[adts]: {% link _overviews/scala3-book/types-adts-gadts.md %}
+[modeling-tools]: {% link _overviews/scala3-book/domain-modeling-tools.md %}

Diff for: _overviews/scala3-book/scala-for-javascript-devs.md

@@ -196,7 +196,17 @@ Many uses of strings are similar in JavaScript and Scala, though Scala only uses
     </tr>
 </table>
 
-Scala lets you create multiline strings, which also support interpolation:
+JavaScript lets you create multiline strings with backticks, and supports interpolation:
+
+```javascript
+let name = "joe";
+let str = `
+Hello, ${name}.
+This is a multiline string.
+`;
+```
+
+Scala lets you create multiline strings with string interpolation:
 
 ```scala
 val name = "Martin Odersky"