Add Scala 3 tabs in _tour/pattern-matching

Author: adpi2

_tour/pattern-matching.md

@@ -15,6 +15,8 @@ Pattern matching is a mechanism for checking a value against a pattern. A succes
 
 ## Syntax
 A match expression has a value, the `match` keyword, and at least one `case` clause.
+{% tabs pattern-matching-1 class=tabs-scala-version %}
+{% tab 'Scala 2' for=pattern-matching-1 %}
 ```scala mdoc
 import scala.util.Random
 
@@ -27,9 +29,26 @@ x match {
   case _ => "other"
 }
 ```
+{% endtab %}
+{% tab 'Scala 3' for=pattern-matching-1 %}
+```scala
+import scala.util.Random
+
+val x: Int = Random.nextInt(10)
+
+x match
+  case 0 => "zero"
+  case 1 => "one"
+  case 2 => "two"
+  case _ => "other"
+```
+{% endtab %}
+{% endtabs %}
 The `val x` above is a random integer between 0 and 10. `x` becomes the left operand of the `match` operator and on the right is an expression with four cases. The last case `_` is a "catch all" case for any other possible `Int` values. Cases are also called _alternatives_.
 
 Match expressions have a value.
+{% tabs pattern-matching-2 class=tabs-scala-version %}
+{% tab 'Scala 2' for=pattern-matching-2 %}
 ```scala mdoc
 def matchTest(x: Int): String = x match {
   case 1 => "one"
@@ -39,26 +58,40 @@ def matchTest(x: Int): String = x match {
 matchTest(3)  // returns other
 matchTest(1)  // returns one
 ```
+{% endtab %}
+
+{% tab 'Scala 3' for=pattern-matching-2 %}
+```scala
+def matchTest(x: Int): String = x match
+  case 1 => "one"
+  case 2 => "two"
+  case _ => "other"
+
+matchTest(3)  // returns other
+matchTest(1)  // returns one
+```
+{% endtab %}
+{% endtabs %}
 This match expression has a type String because all of the cases return String. Therefore, the function `matchTest` returns a String.
 
 ## Matching on case classes
 
 Case classes are especially useful for pattern matching.
 
 ```scala mdoc
-abstract class Notification
+sealed trait Notification
 
 case class Email(sender: String, title: String, body: String) extends Notification
 
 case class SMS(caller: String, message: String) extends Notification
 
 case class VoiceRecording(contactName: String, link: String) extends Notification
-
-
 ```
-`Notification` is an abstract super class which has three concrete Notification types implemented with case classes `Email`, `SMS`, and `VoiceRecording`. Now we can do pattern matching on these case classes:
+`Notification` is a sealed trait which has three concrete Notification types implemented with case classes `Email`, `SMS`, and `VoiceRecording`. Now we can do pattern matching on these case classes:
 
-```
+{% tabs pattern-matching-4 class=tabs-scala-version %}
+{% tab 'Scala 2' for=pattern-matching-4 %}
+```scala
 def showNotification(notification: Notification): String = {
   notification match {
     case Email(sender, title, _) =>
@@ -76,12 +109,36 @@ println(showNotification(someSms))  // prints You got an SMS from 12345! Message
 
 println(showNotification(someVoiceRecording))  // prints You received a Voice Recording from Tom! Click the link to hear it: voicerecording.org/id/123
 ```
+{% endtab %}
+{% tab 'Scala 3' for=pattern-matching-4 %}
+```scala
+def showNotification(notification: Notification): String =
+  notification match
+    case Email(sender, title, _) =>
+      s"You got an email from $sender with title: $title"
+    case SMS(number, message) =>
+      s"You got an SMS from $number! Message: $message"
+    case VoiceRecording(name, link) =>
+      s"You received a Voice Recording from $name! Click the link to hear it: $link"
+
+val someSms = SMS("12345", "Are you there?")
+val someVoiceRecording = VoiceRecording("Tom", "voicerecording.org/id/123")
+
+println(showNotification(someSms))  // prints You got an SMS from 12345! Message: Are you there?
+
+println(showNotification(someVoiceRecording))  // prints You received a Voice Recording from Tom! Click the link to hear it: voicerecording.org/id/123
+```
+{% endtab %}
+{% endtabs %}
+
 The function `showNotification` takes as a parameter the abstract type `Notification` and matches on the type of `Notification` (i.e. it figures out whether it's an `Email`, `SMS`, or `VoiceRecording`). In the `case Email(sender, title, _)` the fields `sender` and `title` are used in the return value but the `body` field is ignored with `_`.
 
 ## Pattern guards
 Pattern guards are simply boolean expressions which are used to make cases more specific. Just add `if <boolean expression>` after the pattern.
-```
 
+{% tabs pattern-matching-5 class=tabs-scala-version %}
+{% tab 'Scala 2' for=pattern-matching-5 %}
+```scala
 def showImportantNotification(notification: Notification, importantPeopleInfo: Seq[String]): String = {
   notification match {
     case Email(sender, _, _) if importantPeopleInfo.contains(sender) =>
@@ -106,40 +163,103 @@ println(showImportantNotification(importantEmail, importantPeopleInfo)) // print
 
 println(showImportantNotification(importantSms, importantPeopleInfo)) // prints You got an SMS from special someone!
 ```
+{% endtab %}
+{% tab 'Scala 3' for=pattern-matching-5 %}
+```scala
+def showImportantNotification(notification: Notification, importantPeopleInfo: Seq[String]): String =
+  notification match
+    case Email(sender, _, _) if importantPeopleInfo.contains(sender) =>
+      "You got an email from special someone!"
+    case SMS(number, _) if importantPeopleInfo.contains(number) =>
+      "You got an SMS from special someone!"
+    case other =>
+      showNotification(other) // nothing special, delegate to our original showNotification function
+
+val importantPeopleInfo = Seq("867-5309", "jenny@gmail.com")
+
+val someSms = SMS("123-4567", "Are you there?")
+val someVoiceRecording = VoiceRecording("Tom", "voicerecording.org/id/123")
+val importantEmail = Email("jenny@gmail.com", "Drinks tonight?", "I'm free after 5!")
+val importantSms = SMS("867-5309", "I'm here! Where are you?")
+
+println(showImportantNotification(someSms, importantPeopleInfo)) // prints You got an SMS from 123-4567! Message: Are you there?
+println(showImportantNotification(someVoiceRecording, importantPeopleInfo)) // prints You received a Voice Recording from Tom! Click the link to hear it: voicerecording.org/id/123
+println(showImportantNotification(importantEmail, importantPeopleInfo)) // prints You got an email from special someone!
+
+println(showImportantNotification(importantSms, importantPeopleInfo)) // prints You got an SMS from special someone!
+```
+{% endtab %}
+{% endtabs %}
 
 In the `case Email(sender, _, _) if importantPeopleInfo.contains(sender)`, the pattern is matched only if the `sender` is in the list of important people.
 
 ## Matching on type only
 You can match on the type like so:
+{% tabs pattern-matching-6 class=tabs-scala-version %}
+{% tab 'Scala 2' for=pattern-matching-6 %}
 ```scala mdoc
-abstract class Device
+sealed trait Device
 case class Phone(model: String) extends Device {
   def screenOff = "Turning screen off"
 }
 case class Computer(model: String) extends Device {
   def screenSaverOn = "Turning screen saver on..."
 }
 
-def goIdle(device: Device) = device match {
+def goIdle(device: Device): String = device match {
   case p: Phone => p.screenOff
   case c: Computer => c.screenSaverOn
 }
 ```
+{% endtab %}
+{% tab 'Scala 3' for=pattern-matching-6 %}
+```scala
+sealed trait Device
+case class Phone(model: String) extends Device:
+  def screenOff = "Turning screen off"
+
+case class Computer(model: String) extends Device:
+  def screenSaverOn = "Turning screen saver on..."
+
+
+def goIdle(device: Device): String = device match
+  case p: Phone => p.screenOff
+  case c: Computer => c.screenSaverOn
+```
+{% endtab %}
+{% endtabs %}
+
 `def goIdle` has a different behavior depending on the type of `Device`. This is useful when the case needs to call a method on the pattern. It is a convention to use the first letter of the type as the case identifier (`p` and `c` in this case).
 
 ## Sealed classes
 Traits and classes can be marked `sealed` which means all subtypes must be declared in the same file. This assures that all subtypes are known.
 
+{% tabs pattern-matching-7 class=tabs-scala-version %}
+{% tab 'Scala 2' for=pattern-matching-7 %}
 ```scala mdoc
-sealed abstract class Furniture
-case class Couch() extends Furniture
-case class Chair() extends Furniture
+sealed trait Furniture
+case object Couch extends Furniture
+case object Chair extends Furniture
 
 def findPlaceToSit(piece: Furniture): String = piece match {
-  case a: Couch => "Lie on the couch"
-  case b: Chair => "Sit on the chair"
+  case Couch => "Lie on the couch"
+  case Chair => "Sit on the chair"
 }
 ```
+{% endtab %}
+{% tab 'Scala 3' for=pattern-matching-7 %}
+```scala
+sealed trait Furniture
+object Couch extends Furniture
+object Chair extends Furniture
+
+def findPlaceToSit(piece: Furniture): String = piece match
+  case Couch => "Lie on the couch"
+  case Chair => "Sit on the chair"
+```
+{% endtab %}
+{% endtabs %}
+
 This is useful for pattern matching because we don't need a "catch all" case.
 
 ## Notes