Fixed warnings for changes in 3.0.0-RC2 and a few bugs missed before!

Author: Dean Wampler

src/script/scala/progscala3/appdesign/Deprecated.scala

@@ -7,7 +7,9 @@ import scala.annotation.nowarn    // This one has to be imported.
 def obsolete(i: Int) = 2*i
 
 def warning(i: Int) = obsolete(i)
-@nowarn def nowarning(i: Int) = obsolete(i)  // No warning for this method
+// In Scala 2, @nowarn would suppress a warning for this method's use of obsolete.
+// This is not (yet?) implemented in Scala 3.
+@nowarn def nowarning(i: Int) = obsolete(i)
 
 def inc(i: Int,
   @deprecatedName("y", "V1.2.3") n: Int): Int = i + n

src/script/scala/progscala3/fp/categories/ForTriesSteps.scala

@@ -20,5 +20,5 @@ def sumCounts(countSteps: Seq[Step]): Try[Int] =                     // <3>
     (sumTry, step) => sumTry.flatMap(i => step(i))
   }
 
-assert(sumCounts(successfulSteps) == Success(40))
-assert(sumCounts(partiallySuccessfulSteps) == Failure(fail))
+assert(sumCounts(successfulSteps).equals(Success(40)))
+assert(sumCounts(partiallySuccessfulSteps).equals(Failure(fail)))

src/script/scala/progscala3/fp/categories/Functor.scala

@@ -3,8 +3,8 @@ import progscala3.fp.categories.*
 
 val fid: Int => Double = i => 1.5 * i
 
-assert(SeqF.map(Seq(1,2,3,4))(fid)   == Seq(1.5, 3.0, 4.5, 6.0))
-assert(SeqF.map(Seq.empty[Int])(fid) == Nil)
+assert(SeqF.map(Seq(1,2,3,4))(fid).equals(Seq(1.5, 3.0, 4.5, 6.0)))
+assert(SeqF.map(Seq.empty[Int])(fid).equals(Nil))
 
-assert(OptionF.map(Some(2))(fid) == Some(3.0))
-assert(OptionF.map(Option.empty[Int])(fid) == None)
+assert(OptionF.map(Some(2))(fid).equals(Some(3.0)))
+assert(OptionF.map(Option.empty[Int])(fid).equals(None))

src/script/scala/progscala3/fp/categories/MapMerge.scala

@@ -12,6 +12,6 @@ map1i.combine(map2i)
 map1s.combine(map2s)
 map1s <+> map2s
 
-assert(map1i.combine(map2i) == Map("one" -> 1, "two" -> 4, "three" -> 3))
-assert(map1s.combine(map2s) == Map("one" -> "1", "two" -> "22", "three" -> "3"))
-assert((map1s <+> map2s) == Map("one" -> "1", "two" -> "22", "three" -> "3"))
+assert(map1i.combine(map2i).equals(Map("one" -> 1, "two" -> 4, "three" -> 3)))
+assert(map1s.combine(map2s).equals(Map("one" -> "1", "two" -> "22", "three" -> "3")))
+assert((map1s <+> map2s).equals(Map("one" -> "1", "two" -> "22", "three" -> "3")))

src/script/scala/progscala3/fp/datastructs/Map.scala

@@ -6,41 +6,41 @@ val stateCapitals = Map(
   "Wyoming" -> "Cheyenne")
 
 val lengths = stateCapitals.map(kv => (kv._1, kv._2.length))
-assert(lengths == Map(
+assert(lengths.equals(Map(
   "Alabama" -> 10,
   "Alaska"  -> 6,
-  "Wyoming" -> 8))
+  "Wyoming" -> 8)))
 
 val caps = stateCapitals.map { case (k, v) => (k, v.toUpperCase) }
-assert(caps ==  Map(
+assert(caps.equals(Map(
   "Alabama" -> "MONTGOMERY",
   "Alaska"  -> "JUNEAU",
-  "Wyoming" -> "CHEYENNE"))
+  "Wyoming" -> "CHEYENNE")))
 
 val caps2 = stateCapitals.map((k, v) => (k, v.toUpperCase))
-assert(caps ==  Map(
+assert(caps.equals(Map(
   "Alabama" -> "MONTGOMERY",
   "Alaska"  -> "JUNEAU",
-  "Wyoming" -> "CHEYENNE"))
+  "Wyoming" -> "CHEYENNE")))
 
 val stateCapitals2a = stateCapitals + ("Virginia" -> "Richmond")
-assert(stateCapitals2a == Map(
+assert(stateCapitals2a.equals(Map(
   "Alabama" -> "Montgomery",
   "Alaska"  -> "Juneau",
   "Wyoming" -> "Cheyenne",
-  "Virginia" -> "Richmond"))
+  "Virginia" -> "Richmond")))
 
 val stateCapitals2b = stateCapitals + ("Alabama" -> "MONTGOMERY")
-assert(stateCapitals2b == Map(
+assert(stateCapitals2b.equals(Map(
   "Alabama" -> "MONTGOMERY",
   "Alaska"  -> "Juneau",
-  "Wyoming" -> "Cheyenne"))
+  "Wyoming" -> "Cheyenne")))
 
 val stateCapitals2 = stateCapitals ++ Seq(
   "Virginia" -> "Richmond", "Illinois" -> "Springfield")
-assert(stateCapitals2 == Map(
+assert(stateCapitals2.equals(Map(
   "Alabama" -> "Montgomery",
   "Alaska"  -> "Juneau",
   "Wyoming" -> "Cheyenne",
   "Virginia" -> "Richmond",
-  "Illinois" -> "Springfield"))
+  "Illinois" -> "Springfield")))

src/script/scala/progscala3/objectsystem/equality/InheritanceEquality.scala

@@ -5,10 +5,10 @@ class Employee(val name: String, val annualSalary: Double)
 class Manager(name: String, annualSalary: Double, val minions: Seq[Employee])
   extends Employee(name, annualSalary)
 
-val e1  = Employee("Buck Trends", 50000.0)
-val e1b = Employee("Buck Trends", 50000.0)
-val e2  = Employee("Jane Doe", 50000.0)
-val m1  = Manager("Jane Doe", 50000.0, Seq(e1, e2))
+val e1  = new Employee("Buck Trends", 50000.0)
+val e1b = new Employee("Buck Trends", 50000.0)
+val e2  = new Employee("Jane Doe", 50000.0)
+val m1  = new Manager("Jane Doe", 50000.0, Seq(e1, e2))
 val all = Seq(e1, e1b, e2, m1)
 // end::definitions[]
 

src/script/scala/progscala3/patternmatching/MatchTreeADTFull.scala

@@ -27,7 +27,7 @@ yield tree match
     r @ SBranch(_,_)) => s"1: l=$l, r=$r, ll=$ll, lli=$lli, lr=$lr, lri=$lri"
   case _: SBranch[?] => "2: Other SBranch"
   case Branch(
-    l @ Branch,
+    l @ Branch(_, _),
     r @ Branch(rl @ Leaf(rli), rr @ Branch(_,_))) =>
       s"3: l=$l, r=$r, rl=$rl, rli=$rli, rr=$rr"
   case _:Branch[?] => "4: Other Branch"

src/script/scala/progscala3/typesystem/deptypes/DependentTypesSimple.scala

@@ -67,7 +67,7 @@ opsInt
 
 // tag::s[]
 def tryS =
-  import scala.compiletime.S
+  import scala.compiletime.ops.int.S
 
   val s1:  S[0] = 1                                             // <1>
   val s2a: S[S[0]] = 2                                          // <2>

src/script/scala/progscala3/typesystem/matchtypes/MatchTypes2.scala

@@ -1,5 +1,7 @@
 // src/script/scala/progscala3/typesystem/matchtypes/MatchTypes2.scala
 // Not in the book. More experimenting with match types.
+import compiletime.asMatchable
+
 type Elem[X <: Matchable] = X match
   case String => Char
   case Array[t] => t
@@ -35,15 +37,16 @@ lastUnsafe(None)
 // Does this parse and provide a safe implementation? No; it has trouble
 // confirming that Char =:= Elem[String] for "s.last" and
 // Matchable =:= Elem[Matchable] for the default Matchable clause.
-def lastOrElse[X <: Matchable](in: X)(default: => Elem[X]): Elem[X] = in match
+
+def lastOrElse[X <: Matchable](in: X)(default: => Elem[X]): Elem[X] = in.asMatchable match
   case s: String => if s.isEmpty then default else s.last
   case a: Array[Elem[X]] => if a.isEmpty then default else a.last
   case i: Iterable[Elem[X]] => if i.isEmpty then default else i.last
   case o: Option[Elem[X]] => o.getOrElse(default)
   case m: Matchable => m
 
 // What about using options? Same parsing problems...
-def lastOption[X <: Matchable](in: X): Option[Elem[X]] = in match
+def lastOption[X <: Matchable](in: X): Option[Elem[X]] = in.asMatchable match
   case s: String => s.lastOption
   case a: Array[Elem[X]] => a.lastOption
   case i: Iterable[Elem[X]] => i.lastOption
@@ -53,7 +56,7 @@ def lastOption[X <: Matchable](in: X): Option[Elem[X]] = in match
 // Surely this will work, no? No; it seems that any attempt to combine the
 // match type Elem[X] with other types, whether "| Null", Option[...], or
 // using it as the type of a default argument fails to work.
-def lastOrNull[X <: Matchable](in: X): Elem[X] | Null = in match
+def lastOrNull[X <: Matchable](in: X): Elem[X] | Null = in.asMatchable match
   case s: String => if s.isEmpty then null else s.last
   case a: Array[Elem[X]] => if a.isEmpty then null else a.last
   case i: Iterable[Elem[X]] => if i.isEmpty then null else i.last
@@ -69,7 +72,7 @@ type RElem[X <: Matchable] = X match
   case Option[t] => RElem[t]
   case Matchable => X
 
-def rlastUnsafe[X <: Matchable](in: X): RElem[X] = in match
+def rlastUnsafe[X <: Matchable](in: X): RElem[X] = in.asMatchable match
   case s: String => s.last
   case a: Array[t] => rlastUnsafe(a.last)
   case i: Iterable[t] => rlastUnsafe(i.last)
@@ -83,21 +86,21 @@ def rlastUnsafe[X <: Matchable](in: X): RElem[X] = in match
 //   case o: Option[RElem[X]] => rlastOrElse(o.getOrElse(default))
 //   case a: Any => a
 
-def rlastOrElse[X](in: X, default: RElem[X]): RElem[X] = in match
+def rlastOrElse[X](in: X, default: RElem[X]): RElem[X] = in.asMatchable match
   case s: String => s.lastOption.getOrElse(default)
   case a: Array[RElem[X]] => rlastOrElse(a.lastOption.getOrElse(default))
   case i: Iterable[RElem[X]] => rlastOrElse(i.lastOption.getOrElse(default))
   case o: Option[RElem[X]] => rlastOrElse(o.getOrElse(default))
   case a: Any => a
 
-def rlastOption[X](in: X): Option[RElem[X]] = in match
+def rlastOption[X](in: X): Option[RElem[X]] = in.asMatchable match
   case s: String => s.lastOption
   case a: Array[RElem[X]] => a.lastOption.flatMap(x => rlastOption(x))
   case i: Iterable[RElem[X]] => i.lastOption.flatMap(x => rlastOption(x))
   case o: Option[RElem[X]] => o.flatMap(x => rlastOption(x))
   case a: Any => Some(a)
 
-def rlastOrNull[X](in: X): RElem[X] | Null = in match
+def rlastOrNull[X](in: X): RElem[X] | Null = in.asMatchable match
   case s: String => if s.isEmpty then null else s.last
   case a: Array[RElem[X]] => if a.isEmpty then null else rlastOrNull(a.last)
   case i: Iterable[RElem[X]] => if i.isEmpty then null else rlastOrNull(i.last)

src/script/scala/progscala3/typesystem/recursivetypes/FBound.scala

@@ -7,8 +7,8 @@ trait Super[T <: Super[T]]:                                     // <1>
 case class Sub1(s: String) extends Super[Sub1]:                 // <3>
   def make: Sub1 = Sub1(s"Sub1: make: $s")
 
-case class Sub2(s: String) extends Super[Sub1]:
-  def make: Sub1 = Sub1(s"Sub2: make: $s")
+case class Sub2(s: String) extends Super[Sub2]:
+  def make: Sub2 = Sub2(s"Sub2: make: $s")
 
 // case class Foo(str:String)                                   // <4>
 // case class Odd(s: String) extends Super[Foo]:

src/script/scala/progscala3/typesystem/structuraltypes/ObserverFunc.scala

@@ -21,5 +21,5 @@ c.increment()
 c.addObserver(observer2.apply)
 c.increment()
 assert(c.count == 3)
-assert(observed1 == 2)
-assert(observed2 == 1)
+assert(observer1.updateCalledCount == 2)
+assert(observer2.updateCalledCount == 1)