adjust formatting

Author: bishabosha

_overviews/scala3-book/domain-modeling-tools.md

@@ -57,7 +57,7 @@ val p = new Person("Robert Allen Zimmerman", "Harmonica Player")
 {% endtab %}
 {% endtabs %}
 
-However, with [creator applications][creator] this isn’t required in Scala 3:
+However, with [universal apply methods][creator] this isn’t required in Scala 3:
 
 {% tabs class_3 %}
 {% tab 'Scala 3 Only' for=class_3 %}
@@ -144,7 +144,21 @@ class Person(var firstName: String, var lastName: String):
 
 The following REPL session shows how to create a new `Person` instance with this class:
 
+{% tabs demo-person class=tabs-scala-version %}
+{% tab 'Scala 2' for=demo-person %}
+````scala
+scala> val john = new Person("John", "Doe")
+initialization begins
+John Doe
+initialization ends
+val john: Person = Person@55d8f6bb
+
+scala> john.printFullName
+John Doe
 ````
+{% endtab %}
+{% tab 'Scala 3' for=demo-person %}
+````scala
 scala> val john = Person("John", "Doe")
 initialization begins
 John Doe
@@ -154,6 +168,8 @@ val john: Person = Person@55d8f6bb
 scala> john.printFullName
 John Doe
 ````
+{% endtab %}
+{% endtabs %}
 
 Classes can also extend traits and abstract classes, which we cover in dedicated sections below.
 
@@ -184,8 +200,19 @@ class Socket(val timeout: Int = 5_000, val linger: Int = 5_000):
 
 A great thing about this feature is that it lets consumers of your code create classes in a variety of different ways, as though the class had alternate constructors:
 
-{% tabs default-values_2 %}
-{% tab 'Scala 2 and 3' for=default-values_2 %}
+{% tabs default-values_2 class=tabs-scala-version %}
+{% tab 'Scala 2' for=default-values_2 %}
+
+```scala
+val s = new Socket()                  // timeout: 5000, linger: 5000
+val s = new Socket(2_500)             // timeout: 2500, linger: 5000
+val s = new Socket(10_000, 10_000)    // timeout: 10000, linger: 10000
+val s = new Socket(timeout = 10_000)  // timeout: 10000, linger: 5000
+val s = new Socket(linger = 10_000)   // timeout: 5000, linger: 10000
+```
+
+{% endtab %}
+{% tab 'Scala 3' for=default-values_2 %}
 
 ```scala
 val s = Socket()                  // timeout: 5000, linger: 5000
@@ -201,8 +228,22 @@ val s = Socket(linger = 10_000)   // timeout: 5000, linger: 10000
 When creating a new instance of a class, you can also use named parameters.
 This is particularly helpful when many of the parameters have the same type, as shown in this comparison:
 
-{% tabs default-values_3 %}
-{% tab 'Scala 2 and 3' for=default-values_3 %}
+{% tabs default-values_3 class=tabs-scala-version %}
+{% tab 'Scala 2' for=default-values_3 %}
+
+```scala
+// option 1
+val s = new Socket(10_000, 10_000)
+
+// option 2
+val s = new Socket(
+  timeout = 10_000,
+  linger = 10_000
+)
+```
+
+{% endtab %}
+{% tab 'Scala 3' for=default-values_3 %}
 
 ```scala
 // option 1
@@ -254,7 +295,7 @@ class Student(
     this(name, govtId)
     _applicationDate = Some(applicationDate)
   }
-  
+
   // [3] a constructor for when the student is approved
   // and now has a student id
   def this(
@@ -481,15 +522,15 @@ For instance, in the following example the class `Circle` has a member named `ar
 ```scala
 import scala.math._
 
-case class Circle(radius: Double) {
+class Circle(val radius: Double) {
   def area: Double = Circle.calculateArea(radius)
 }
 
 object Circle {
   private def calculateArea(radius: Double): Double = Pi * pow(radius, 2.0)
 }
 
-val circle1 = Circle(5.0)
+val circle1 = new Circle(5.0)
 circle1.area
 ```
 
@@ -500,7 +541,7 @@ circle1.area
 ```scala
 import scala.math.*
 
-case class Circle(radius: Double):
+class Circle(val radius: Double):
   def area: Double = Circle.calculateArea(radius)
 
 object Circle:
@@ -546,7 +587,7 @@ object Person {
     p.name = name
     p
   }
-  
+
   // a two-arg factory method
   def apply(name: String, age: Int): Person = {
     var p = new Person
@@ -563,6 +604,8 @@ val fred = Person("Fred", 29)
 //val fred: Person = Fred is 29 years old
 ```
 
+The `unapply` method isn’t covered here, but it’s covered in the [Language Specification](https://scala-lang.org/files/archive/spec/2.13/08-pattern-matching.html#extractor-patterns).
+
 {% endtab %}
 
 {% tab 'Scala 3' for=companion-use %}
@@ -597,11 +640,11 @@ val fred = Person("Fred", 29)
 //val fred: Person = Fred is 29 years old
 ```
 
+The `unapply` method isn’t covered here, but it’s covered in the [Reference documentation]({{ site.scala3ref }}/changed-features/pattern-matching.html).
+
 {% endtab %}
 {% endtabs %}
 
-The `unapply` method isn’t covered here, but it’s covered in the [Reference documentation][unapply].
-
 ## Traits
 
 If you’re familiar with Java, a Scala trait is similar to an interface in Java 8+. Traits can contain:
@@ -700,7 +743,7 @@ Later in your code, classes can mix multiple traits to build larger components:
 {% tab 'Scala 2' for=traits_4 %}
 
 ```scala
-class IrishSetter(name: String) extends HasLegs, HasTail {
+class IrishSetter(name: String) extends HasLegs with HasTail {
   val numLegs = 4
   val tailColor = "Red"
   def walk() = println("I’m walking")
@@ -726,8 +769,15 @@ class IrishSetter(name: String) extends HasLegs, HasTail:
 Notice that the `IrishSetter` class implements the abstract members that are defined in `HasLegs` and `HasTail`.
 Now you can create new `IrishSetter` instances:
 
-{% tabs traits_5 %}
-{% tab 'Scala 2 and 3' for=traits_5 %}
+{% tabs traits_5 class=tabs-scala-version %}
+{% tab 'Scala 2' for=traits_5 %}
+
+```scala
+val d = new IrishSetter("Big Red")   // "Big Red is a Dog"
+```
+
+{% endtab %}
+{% tab 'Scala 3' for=traits_5 %}
 
 ```scala
 val d = IrishSetter("Big Red")   // "Big Red is a Dog"
@@ -775,7 +825,7 @@ class Dog(name: String, var age: Int) extends Pet(name) {
   val greeting = "Woof"
 }
 
-val d = Dog("Fido", 1)
+val d = new Dog("Fido", 1)
 ```
 
 {% endtab %}
@@ -799,26 +849,9 @@ val d = Dog("Fido", 1)
 
 However, with Scala 3, traits can now have [parameters][trait-params], so you can now use traits in the same situation:
 
-{% tabs abstract_2 class=tabs-scala-version %}
-{% tab 'Scala 2' for=abstract_2 %}
-
-```scala
-trait Pet(name: String) {
-  def greeting: String
-  def age: Int
-  override def toString = s"My name is $name, I say $greeting, and I’m $age"
-}
-
-class Dog(name: String, var age: Int) extends Pet(name) {
-  val greeting = "Woof"
-}
-
-val d = Dog("ssssssss
-```
-
-{% endtab %}
+{% tabs abstract_2 %}
 
-{% tab 'Scala 3' for=abstract_2 %}
+{% tab 'Scala 3 Only' for=abstract_2 %}
 
 ```scala
 trait Pet(name: String):
@@ -875,18 +908,18 @@ val currentCrustSize = Small
 {% endtab %}
 {% endtabs %}
 
-Enum values can be compared using equals (`==`), and also enum_1ed on:
+Enum values can be compared using equals (`==`), and also matched on:
 
 {% tabs enum_3 %}
 {% tab 'Scala 3 Only' for=enum_3 %}
 
 ```scala
 // if/then
-if (currentCrustSize == Large)
+if currentCrustSize == Large then
   println("You get a prize!")
 
-// enum_1
-currentCrustSize enum_1
+// match
+currentCrustSize match
   case Small => println("small")
   case Medium => println("medium")
   case Large => println("large")
@@ -1000,7 +1033,7 @@ christina.name = "Fred"   // error: reassignment to val
 
 Since the fields of a case class are assumed to be immutable, the Scala compiler can generate many helpful methods for you:
 
-- An `unapply` method is generated, which allows you to perform pattern case-classes_1ing on a case class (that is, `case Person(n, r) => ...`).
+- An `unapply` method is generated, which allows you to perform pattern matching on a case class (that is, `case Person(n, r) => ...`).
 - A `copy` method is generated in the class, which is very useful to create modified copies of an instance.
 - `equals` and `hashCode` methods using structural equality are generated, allowing you to use instances of case classes in `Map`s.
 - A default `toString` method is generated, which is helpful for debugging.
@@ -1038,7 +1071,7 @@ val cubs2016 = cubs1908.copy(lastWorldSeriesWin = 2016)
 
 ```scala
 // Case classes can be used as patterns
-christina match:
+christina match
   case Person(n, r) => println("name is " + n)
 
 // `equals` and `hashCode` methods generated for you
@@ -1068,7 +1101,7 @@ As mentioned, case classes support functional programming (FP):
   Since instances of case classes can’t be changed, they can easily be shared without fearing mutation or race conditions.
 - Instead of mutating an instance, you can use the `copy` method as a template to create a new (potentially changed) instance.
   This process can be referred to as “update as you copy.”
-- Having an `unapply` method auto-generated for you also lets case classes be used in advanced ways with pattern case-classes_1ing.
+- Having an `unapply` method auto-generated for you also lets case classes be used in advanced ways with pattern matching.
 
 {% comment %}
 NOTE: We can use this following text, if desired. If it’s used, it needs to be updated a little bit.
@@ -1113,7 +1146,7 @@ case class Teacher(name: String, specialty: String) extends Person
 {% endtab %}
 {% endtabs %}
 
-Because those are defined as case classes---and they have built-in `unapply` methods---you can write a case-classes_1 expression like this:
+Because those are defined as case classes---and they have built-in `unapply` methods---you can write a match expression like this:
 
 {% tabs case-classes_7 class=tabs-scala-version %}
 {% tab 'Scala 2' for=case-classes_7 %}
@@ -1156,7 +1189,7 @@ case Teacher(name, whatTheyTeach) =>
 {% endtabs %}
 
 Those patterns work because `Student` and `Teacher` are defined as case classes that have `unapply` methods whose type signature conforms to a certain standard.
-Technically, the specific type of pattern case-classes_1ing shown in these examples is known as a _constructor pattern_.
+Technically, the specific type of pattern matching shown in these examples is known as a _constructor pattern_.
 
 > The Scala standard is that an `unapply` method returns the case class constructor fields in a tuple that’s wrapped in an `Option`.
 > The “tuple” part of the solution was shown in the previous lesson.
@@ -1192,9 +1225,9 @@ res1: String = Bob Donnan teaches Mathematics.
 
 > All of this content on `unapply` methods and extractors is a little advanced for an introductory book like this, but because case classes are an important FP topic, it seems better to cover them, rather than skipping over them.
 
-#### Add pattern case-classes_1ing to any type with unapply
+#### Add pattern matching to any type with unapply
 
-A great Scala feature is that you can add pattern case-classes_1ing to any type by writing your own `unapply` method.
+A great Scala feature is that you can add pattern matching to any type by writing your own `unapply` method.
 As an example, this class defines an `unapply` method in its companion object:
 
 {% tabs case-classes_11 class=tabs-scala-version %}
@@ -1220,7 +1253,7 @@ object Person:
 {% endtab %}
 {% endtabs %}
 
-Because it defines an `unapply` method, and because that method returns a tuple, you can now use `Person` with a `case-classes_1` expression:
+Because it defines an `unapply` method, and because that method returns a tuple, you can now use `Person` with a `match` expression:
 
 {% tabs case-classes_12 class=tabs-scala-version %}
 {% tab 'Scala 2' for=case-classes_12 %}
@@ -1277,7 +1310,7 @@ case object StopPlaying extends Message
 {% endtab %}
 {% endtabs %}
 
-Then in other parts of your code, you can write methods like this, which use pattern case-objects_1ing to handle the incoming message (assuming the methods `playSong`, `changeVolume`, and `stopPlayingSong` are defined somewhere else):
+Then in other parts of your code, you can write methods like this, which use pattern matching to handle the incoming message (assuming the methods `playSong`, `changeVolume`, and `stopPlayingSong` are defined somewhere else):
 
 {% tabs case-objects_2 class=tabs-scala-version %}
 {% tab 'Scala 2' for=case-objects_2 %}