Fixed obsolete implicit methods and classes examples.

Signed-off-by: Dean Wampler <dean.wampler@ibm.com>

Author: deanwampler

build.sbt

@@ -50,9 +50,9 @@ lazy val root = project
       // "-old-syntax",                       // Require `(...)` around conditions.
       // "-language:Scala2",                  // Compile Scala 2 code, highlight what needs updating
       // "-language:strictEquality",          // Require +derives Eql+ for using == or != comparisons
-      // "-rewrite",                          // Attempt to fix code automatically. Use with -indent and ...-migration.
       // "-scalajs",                          // Compile in Scala.js mode (requires scalajs-library.jar on the classpath).
-      // "-source:future",                       // Choices: future and future-migration. I use this to force future deprecation warnings, etc.
+      "-source:future-migration",          // Choices: future and future-migration. I use this to force future deprecation warnings, etc.
+      "-rewrite",                          // Rewrite source, when necessary, for future migration - DeanW: added Sept 2025
       "-Xfatal-warnings",                  // Fail on warnings, not just errors
       // "-Xmigration",                       // Warn about constructs whose behavior may have changed since version.
       // "-Ysafe-init",                       // Warn on field access before initialization

check-scripts.sh

@@ -6,11 +6,15 @@ out_ext="out"
 timestamp=$(date +"%Y-%m-%d_%H-%M-%S")
 error_log="$out_root/scripts-errors-$timestamp.log"
 expected_errors_in=(
-
   src/script/scala/progscala3/IndentationSyntax.scala
   src/script/scala/progscala3/appdesign/Deprecated.scala
+  src/script/scala/progscala3/basicoop/DollarsPercentagesOpaque.scala
+  src/script/scala/progscala3/basicoop/GoodBad.scala
   src/script/scala/progscala3/basicoop/MatchableOpaque.scala
+  src/script/scala/progscala3/basicoop/tagging/Tags.scala
+  src/script/scala/progscala3/basicoop/tagging/Tags2.scala
   src/script/scala/progscala3/collections/MultiMap.scala
+  src/script/scala/progscala3/contexts/ExtensionMethodScoping.scala
   src/script/scala/progscala3/contexts/ImplicitEvidence.scala
   src/script/scala/progscala3/contexts/ImplicitNotFound.scala
   src/script/scala/progscala3/contexts/MatchGivens.scala
@@ -31,6 +35,7 @@ expected_errors_in=(
   src/script/scala/progscala3/rounding/InfixMethod.scala
   src/script/scala/progscala3/rounding/InfixType.scala
   src/script/scala/progscala3/rounding/TypeErasureProblem.scala
+  src/script/scala/progscala3/typelessdomore/FibonacciTailrec.scala
   src/script/scala/progscala3/typelessdomore/Human.scala
   src/script/scala/progscala3/typelessdomore/MethodBroadInference.scala
   src/script/scala/progscala3/typelessdomore/MethodNestedReturn.scala

src/main/scala/progscala3/basicoop/tagging/Tags2.scala

@@ -21,11 +21,11 @@ object Tagging2:
   @targetName("Tag") type @@[S, T] = Tagged[S, T]
 
   /**
+   * Pre Scala 3.7.X:
    * Instead of extension methods, use implicit conversions to value classes,
    * which won't add any runtime overhead, but allow us to use methods like `tag`
    * the way we want. This implementation is closer to the original example in
    * SIP-35.
-   */
   implicit class tagOps[S](s: S):
     def tag[T]: S @@ T = Tagged.tag(s)
   implicit class untagOps[S, T](st: S @@ T):
@@ -34,6 +34,23 @@ object Tagging2:
     def tags[T]: F[S @@ T] = Tagged.tags(fs)
   implicit class untagsOps[F[_], S, T](fst: F[S @@ T]):
     def untags: F[S] = Tagged.untags(fst)
+  */
+
+  /**
+   * DeanW (September 2025): as of Scala 3.7.X, implicit classes are no longer
+   * supported. Alternative are extension methods and declaring regular classes 
+   * and using given conversions to them. Here, we go back to using extension methods!
+   */
+
+  extension [S](s: S)
+    def tag[T]: S @@ T = Tagged.tag(s)
+  extension [S, T](st: S @@ T)
+    def untag: S = Tagged.untag(st)
+  extension [F[_], S](fs: F[S])
+    def tags[T]: F[S @@ T] = Tagged.tags(fs)
+  extension [F[_], S, T](fst: F[S @@ T])
+    def untags: F[S] = Tagged.untags(fst)
+
 end Tagging2
 
 @main def TryTagging2(): Unit =

src/main/scala/progscala3/contexts/typeclass/UsingClauses.scala

@@ -0,0 +1,71 @@
+// tag::definitions[]
+// src/main/scala/progscala3/contexts/UsingClauses.scala
+// This is identical to src/script/scala/progscala3/contexts/UsingClauses.scala,
+// with the method invocations moved to a new @main function at the end.
+// I created it just to make it easier to test some work, and decided it 
+// "doesn't hurt" to keep it around, but only the script version is used in the
+// book.
+
+case class SortableSeq[A](seq: Seq[A]):
+  def sortBy1a[B](transform: A => B)(using o: Ordering[B]): SortableSeq[A] =
+    SortableSeq(seq.sortBy(transform)(using o))
+
+  def sortBy1b[B](transform: A => B)(using Ordering[B]): SortableSeq[A] =
+    SortableSeq(seq.sortBy(transform)(using summon[Ordering[B]]))
+
+  def sortBy2[B : Ordering](transform: A => B): SortableSeq[A] =
+    SortableSeq(seq.sortBy(transform)(using summon[Ordering[B]]))
+// end::definitions[]
+
+// tag::defaultOrdering[]
+def defaultOrdering() =
+  val seq = SortableSeq(Seq(1,3,5,2,4))
+  val expected = SortableSeq(Seq(5, 4, 3, 2, 1))
+  assert(seq.sortBy1a(i => -i) == expected)
+  assert(seq.sortBy1b(i => -i) == expected)
+  assert(seq.sortBy2(i => -i)  == expected)
+
+// end::defaultOrdering[]
+
+// tag::oddEvenImplicitOrdering[]
+def oddEvenImplicitOrdering() =
+  implicit val oddEven: Ordering[Int] = new Ordering[Int]:
+    def compare(i: Int, j: Int): Int = i%2 compare j%2 match
+      case 0 => i compare j
+      case c => c
+
+  val seq = SortableSeq(Seq(1,3,5,2,4))
+  val expected = SortableSeq(Seq(5, 3, 1, 4, 2))
+  assert(seq.sortBy1a(i => -i) == expected)
+  assert(seq.sortBy1b(i => -i) == expected)
+  assert(seq.sortBy2(i => -i)  == expected)
+
+  assert(seq.sortBy1a(i => -i)(using oddEven) == expected)
+  assert(seq.sortBy1b(i => -i)(using oddEven) == expected)
+  assert(seq.sortBy2(i => -i)(using oddEven)  == expected)
+
+// end::oddEvenImplicitOrdering[]
+
+// tag::oddEvenGivenOrdering[]
+def evenOddGivenOrdering() =
+  given evenOdd: Ordering[Int]:
+    def compare(i: Int, j: Int): Int = i%2 compare j%2 match
+      case 0 => i compare j
+      case c => -c
+
+  val seq = SortableSeq(Seq(1,3,5,2,4))
+  val expected = SortableSeq(Seq(4, 2, 5, 3, 1))
+  assert(seq.sortBy1a(i => -i) == expected)                     // <1>
+  assert(seq.sortBy1b(i => -i) == expected)
+  assert(seq.sortBy2(i => -i)  == expected)
+
+  assert(seq.sortBy1a(i => -i)(using evenOdd) == expected)      // <2>
+  assert(seq.sortBy1b(i => -i)(using evenOdd) == expected)
+  assert(seq.sortBy2(i => -i)(using evenOdd)  == expected)
+
+// end::oddEvenGivenOrdering[]
+
+@main def checkUsingClauses() =
+  defaultOrdering()
+  oddEvenImplicitOrdering()
+  evenOddGivenOrdering()

src/main/scala/progscala3/contexts/typeclass/old/ToJSONTypeClasses.scala

@@ -4,51 +4,47 @@ package progscala3.contexts.typeclass.old
 
 import progscala3.introscala.shapes.{Point, Shape, Circle, Rectangle, Triangle}
 
-trait ToJSONOld[T]:
-  def toJSON(name: String = "", level: Int = 0): String         // <1>
+// DeanW: September 14, 2025. Scala is dropping support for implicit classes, so the 
+// `implicit final class PointToJSON`, etc. are now replaced by extension methods
+// and the trait ToJSONOld is converted to an object for its methods.
 
-  protected val indent = "  "
-  protected def indentation(level: Int): (String,String) =
+object ToJSONOld:
+  val indent = "  "
+  def indentation(level: Int): (String,String) =
     (indent * level, indent * (level+1))
-  protected def handleName(name: String): String =
+  def handleName(name: String): String =
     if name.length > 0 then s""""$name": """ else ""
-// end::trait[]
+end ToJSONOld
 
-// tag::pointcircle[]
-implicit final class PointToJSON(
-    point: Point) extends ToJSONOld[Point]:
-  def toJSON(name: String = "", level: Int = 0): String =
-    val (outdent, indent) = indentation(level)
-    s"""${handleName(name)}{
+extension(point: Point)
+  def toJSON(name: String, level: Int): String =
+    val (outdent, indent) = ToJSONOld.indentation(level)
+    s"""${ToJSONOld.handleName(name)}{
       |${indent}"x": "${point.x}",
       |${indent}"y": "${point.y}"
       |$outdent}""".stripMargin
 
-implicit final class CircleToJSON(
-    circle: Circle) extends ToJSONOld[Circle]:
-  def toJSON(name: String = "", level: Int = 0): String =
-    val (outdent, indent) = indentation(level)
-    s"""${handleName(name)}{
+extension(circle: Circle)
+  def toJSON(name: String, level: Int): String =
+    val (outdent, indent) = ToJSONOld.indentation(level)
+    s"""${ToJSONOld.handleName(name)}{
       |${indent}${circle.center.toJSON("center", level + 1)},
       |${indent}"radius": ${circle.radius}
       |$outdent}""".stripMargin
-// end::pointcircle[]
 
-implicit final class RectangleToJSON(
-    rect: Rectangle) extends ToJSONOld[Rectangle]:
-  def toJSON(name: String = "", level: Int = 0): String =
-    val (outdent, indent) = indentation(level)
-    s"""${handleName(name)}{
+extension(rect: Rectangle)
+  def toJSON(name: String, level: Int): String =
+    val (outdent, indent) = ToJSONOld.indentation(level)
+    s"""${ToJSONOld.handleName(name)}{
       |${indent}${rect.lowerLeft.toJSON("lowerLeft", level + 1)},
       |${indent}"height":    ${rect.height}
       |${indent}"width":     ${rect.width}
       |$outdent}""".stripMargin
 
-implicit final class TriangleToJSON(
-    tri: Triangle) extends ToJSONOld[Triangle]:
-  def toJSON(name: String = "", level: Int = 0): String =
-    val (outdent, indent) = indentation(level)
-    s"""${handleName(name)}{
+extension(tri: Triangle)
+  def toJSON(name: String, level: Int): String =
+    val (outdent, indent) = ToJSONOld.indentation(level)
+    s"""${ToJSONOld.handleName(name)}{
       |${indent}${tri.point1.toJSON("point1", level + 1)},
       |${indent}${tri.point2.toJSON("point2", level + 1)},
       |${indent}${tri.point3.toJSON("point3", level + 1)},

src/main/scala/progscala3/dsls/payroll/Money.scala

@@ -9,10 +9,21 @@ given Floating[Dollars]:                                    // <3>
 given Floating[Percentage]:
   def fromDigits(digits: String): Percentage = Percentage(digits.toDouble)
 
-implicit class dsc(sc: StringContext):                          // <4>
+/**
+ * DeanW (September 2025): as of Scala 3.7.X, implicit classes are no longer
+ * supported. Alternative are extension methods and declaring regular classes 
+ * with given conversions. Here, we'll use the latter:
+implicit class dsc(sc: StringContext):
   def $(tokens: Any*) =
     val str = StringContextUtil.foldTokens(tokens.toSeq, sc.parts)
     Dollars(str.toDouble)
+ */
+
+class dsc(sc: StringContext):                                   // <4>
+  def $(tokens: Any*) =
+    val str = StringContextUtil.foldTokens(tokens.toSeq, sc.parts)
+    Dollars(str.toDouble)
+given Conversion[StringContext, dsc] = sc => dsc(sc)
 
 extension (amount: Double)                                      // <5>
   def dollars: Dollars = Dollars(amount)

src/script/scala/progscala3/contexts/UsingClauses.scala

@@ -25,7 +25,9 @@ defaultOrdering()
 
 // tag::oddEvenImplicitOrdering[]
 def oddEvenImplicitOrdering() =
-  implicit val oddEven: Ordering[Int] = new Ordering[Int]:
+  // DeanW - Sept 2025: implicit vals are no longer supported:
+  // implicit val oddEven: Ordering[Int] = new Ordering[Int]:
+  given oddEven: Ordering[Int] = new Ordering[Int]:
     def compare(i: Int, j: Int): Int = i%2 compare j%2 match
       case 0 => i compare j
       case c => c

src/test/scala/progscala3/contexts/CustomStringInterpolatorSuite.scala

@@ -6,7 +6,12 @@ import munit.*
 class CustomStringInterpolatorSuite extends FunSuite:
 
   object JSONToMapInterpolator:
-    implicit class mapForStringContext(val sc: StringContext):  // <1>
+    /* DeanW: September 2025. Scala is dropping support for implicit classes, 
+     * so we use an extension method instead:
+     * implicit class mapForStringContext(val sc: StringContext):
+     *   def map(values: String*): Map[String, String] = ...     
+     */
+    extension (sc: StringContext)                               // <1>
       def map(values: String*): Map[String, String] =           // <2>
         val keyRE = """^[\s{,]*(\S+):\s*""".r                   // <3>
         val keys = sc.parts map {                               // <4>

src/test/scala/progscala3/contexts/ImplicitConversionResolutionSuite.scala

@@ -8,17 +8,27 @@ class ImplicitConversionResolutionSuite extends FunSuite:
 
   case class Foo(s: String)
   object Foo:
-    implicit def fromString(s: String): Foo =
-      Foo(s"Foo's implicit conversion: $s")
+    /* DeanW: September 2025. Scala is dropping support for implicit classes, 
+     * so we use a given Conversion instead:
+     * implicit def fromString(s: String): Foo =
+     *   Foo(s"Foo's implicit conversion: $s")
+     */
+    given Conversion[String, Foo] = 
+      s => Foo(s"Foo's implicit conversion: $s")
 
   object scope1:
     import Foo.*
     def apply(foo: Foo): String  = foo.s
 
   object scope2:
     object implicits:
-      implicit def overridingConversion(s: String): Foo =
-        Foo(s"scope2's implicit conversion: $s")
+      /* DeanW: September 2025. Scala is dropping support for implicit classes, 
+       * so we use a given Conversion instead:
+       * implicit def overridingConversion(s: String): Foo =
+       *   Foo(s"scope2's implicit conversion: $s")
+       */
+      given Conversion[String, Foo] = 
+        s => Foo(s"scope2's implicit conversion: $s")
 
     def apply(foo: Foo): String  = foo.s
 
@@ -28,7 +38,9 @@ class ImplicitConversionResolutionSuite extends FunSuite:
   }
 
   test("The closest implicit conversion in scope is invoked") {
-    import scope2.implicits.*
+    // DeanW - September 2025: Now we need to import the given:
+    // import scope2.implicits.*
+    import scope2.implicits.given
     assert(scope2(Foo("no use of conversion")) == "no use of conversion")
-    assert(scope2("foo") == "scope2's implicit conversion: foo")
+    assert(scope2("foo") == "scope2's implicit conversion: foo", scope2("foobar"))
   }

src/test/scala/progscala3/contexts/TypeClassesSubtypingSuite.scala

@@ -5,10 +5,22 @@ import munit.*
 
 class TypeClassesSubtypingSuite extends FunSuite:
 
-  trait Stringizer[+T]:
-    def stringize: String
-
-  implicit class AnyStringizer(a: Matchable) extends Stringizer[Matchable]:
+  /* DeanW: September 2025. Scala is dropping support for implicit classes, 
+   * so we use an extension method instead:
+   * 
+   *   trait Stringizer[+T]:
+   *     def stringize: String
+   *
+   *   implicit class AnyStringizer(a: Matchable) extends Stringizer[Matchable]:
+   *     def stringize: String = a match
+   *       case s: String => s
+   *       case i: Int => (i*10).toString
+   *       case f: Float => (f*10).toString
+   *       case other =>
+   *         throw UnsupportedOperationException(s"Can't stringize $other")
+   */
+
+  extension (a: Matchable)
     def stringize: String = a match
       case s: String => s
       case i: Int => (i*10).toString