Add exercise opaque type aliases (#121)

* Add slide for extra exercise on opaque type aliases

* Rename exercise on opaque type aliases

- Make it apparent in the exercise name that this is an optional
  exercise

* Checkpoint result of running 'ctma renumber-exercises -f 9 -t 10 -s 1'

* Checkpoint result of running 'ctma duplicate-insert-before -n 9'

* Add exercise and instructions

- Extra exercise on opaque type aliases and comparing them to
  other alternatives such as value classes

* Checkpoint result of running 'ctma renumber-exercises -f 13 -t 20 -s 1'

Author: eloots

exercises/exercise_010_opaque_type_aliases/.scalafmt.conf renamed to exercises/exercise_010_exploring_opaque_type_aliases/.scalafmt.conf

@@ -0,0 +1,45 @@
+# Exploring Opaque type aliases
+
+## Background
+
+In the chapter on Opaque type aliases, we did a quick review of the various features in
+Scala that allow us to abstract over certain types without incurring the overhead of
+boxing/unboxing. We saw that some of these features (Value classes for example) fail
+to achieve this goal under certain circumstances.
+
+In this exercise, you will look at the aforementioned features and have a look at the
+generated byte code to see whether boxing occurs or not.
+
+## Steps
+
+- Clone this repo: [Moving from Scala 2 to Scala 3](https://github.com/lunatech-labs/lunatech-scala2-to-scala3-course)
+
+- In the cloned repository, `cd` into the `code-snippets` folder
+- This folder holds a multi-project `sbt` build. Load this project into your IDE (IntelliJ
+  or VSCode with Metals)
+- We will focus on the `opaque-type-aliases` `sbt` project for this exercise
+
+- Start an `sbt` session in the `code-snippets` folder and compile the project
+
+We will now walk through the different features
+
+### Case class wrappers
+
+- Have a look at the source code in the `CaseClasses.scala` file in the `opaquetypelaliases.caseclasses` package
+- The Scala compiler has generated class files for this under the `target/scala-3.3.0/classes/opaquetypealiases/caseclasses` folder
+- Decompile the different class files using:
+    - VSCode with Metals: the `cfr` Java decompiler: right-click on a class file. Select `Metals Analyse Source`/`Show decompiled with CFR`
+    - IntelliJ: right-click on a class file. Select `Show Decompiled Class As Java`
+- Look at the decompiled code and figure out whether boxing occurs or not.
+
+### Value-class wrappers
+
+- Repeat the same steps for file `ValueClasses.scala` in the `opaquetypelaliases.valueclasses` package
+
+- Repeat for `ParametricPolymorphism.scala` in the `opaquetypelaliases.parametricpolymorphism` package
+
+- Repeat for `Subtyping.scala` in the `opaquetypelaliases.subtyping` package
+
+### Opaque type aliases
+
+- Repeat the same steps for file `UsingTheAliases.scala` in the `opaquetypelaliases.opaquetypealias`

exercises/exercise_010_opaque_type_aliases/IDE-Setup.md renamed to exercises/exercise_010_exploring_opaque_type_aliases/IDE-Setup.md

@@ -0,0 +1,40 @@
+package org.lunatechlabs.dotty.sudoku
+
+// Extension instance wraps extension methods for type ReductionSet
+extension (reductionSet: ReductionSet)
+
+  def applyReductionRuleOne: ReductionSet =
+    val inputCellsGrouped = reductionSet.filter { _.size <= 7 }.groupBy(identity)
+    val completeInputCellGroups = inputCellsGrouped.filter { (set, setOccurrences) =>
+      set.size == setOccurrences.length
+    }
+    val completeAndIsolatedValueSets = completeInputCellGroups.keys.toList
+    completeAndIsolatedValueSets.foldLeft(reductionSet) { (cells, caivSet) =>
+      cells.map { cell =>
+        if cell != caivSet then cell &~ caivSet else cell
+      }
+    }
+
+  def applyReductionRuleTwo: ReductionSet =
+    val valueOccurrences = CellPossibleValues.map { value =>
+      cellIndexesVector.zip(reductionSet).foldLeft(Vector.empty[Int]) { case (acc, (index, cell)) =>
+        if cell contains value then index +: acc else acc
+      }
+    }
+
+    val cellIndexesToValues =
+      CellPossibleValues.zip(valueOccurrences).groupBy((value, occurrence) => occurrence).filter { case (loc, occ) =>
+        loc.length == occ.length && loc.length <= 6
+      }
+
+    val cellIndexListToReducedValue = cellIndexesToValues.map { (index, seq) =>
+      (index, seq.map((value, _) => value).toSet)
+    }
+
+    val cellIndexToReducedValue = cellIndexListToReducedValue.flatMap { (cellIndexList, reducedValue) =>
+      cellIndexList.map(cellIndex => cellIndex -> reducedValue)
+    }
+
+    reductionSet.zipWithIndex.foldRight(Vector.empty[CellContent]) { case ((cellValue, cellIndex), acc) =>
+      cellIndexToReducedValue.getOrElse(cellIndex, cellValue) +: acc
+    }

exercises/exercise_010_exploring_opaque_type_aliases/README.md

@@ -0,0 +1,100 @@
+package org.lunatechlabs.dotty.sudoku
+
+import akka.actor.typed.scaladsl.{ActorContext, Behaviors}
+import akka.actor.typed.{ActorRef, Behavior}
+
+object SudokuDetailProcessor:
+
+  // My protocol
+  enum Command:
+    case ResetSudokuDetailState
+    case Update(cellUpdates: CellUpdates, replyTo: ActorRef[Response])
+    case GetSudokuDetailState(replyTo: ActorRef[SudokuProgressTracker.Command])
+  export Command.*
+
+  // My responses
+  enum Response:
+    case RowUpdate(id: Int, cellUpdates: CellUpdates)
+    case ColumnUpdate(id: Int, cellUpdates: CellUpdates)
+    case BlockUpdate(id: Int, cellUpdates: CellUpdates)
+    case SudokuDetailUnchanged
+  export Response.*
+
+  def apply[DetailType <: SudokuDetailType](id: Int, state: ReductionSet = InitialDetailState)(using
+      updateSender: UpdateSender[DetailType]): Behavior[Command] =
+    Behaviors.setup { context =>
+      (new SudokuDetailProcessor[DetailType](context)).operational(id, state, fullyReduced = false)
+    }
+
+  trait UpdateSender[A]:
+    def sendUpdate(id: Int, cellUpdates: CellUpdates)(using sender: ActorRef[Response]): Unit
+    def processorName(id: Int): String
+
+  given UpdateSender[Row] with
+    override def sendUpdate(id: Int, cellUpdates: CellUpdates)(using sender: ActorRef[Response]): Unit =
+      sender ! RowUpdate(id, cellUpdates)
+    def processorName(id: Int): String = s"row-processor-$id"
+
+  given UpdateSender[Column] with
+    override def sendUpdate(id: Int, cellUpdates: CellUpdates)(using sender: ActorRef[Response]): Unit =
+      sender ! ColumnUpdate(id, cellUpdates)
+    def processorName(id: Int): String = s"col-processor-$id"
+
+  given UpdateSender[Block] with
+    override def sendUpdate(id: Int, cellUpdates: CellUpdates)(using sender: ActorRef[Response]): Unit =
+      sender ! BlockUpdate(id, cellUpdates)
+    def processorName(id: Int): String = s"blk-processor-$id"
+
+class SudokuDetailProcessor[DetailType <: SudokuDetailType: SudokuDetailProcessor.UpdateSender] private (
+    context: ActorContext[SudokuDetailProcessor.Command]):
+
+  import SudokuDetailProcessor.*
+
+  def operational(id: Int, state: ReductionSet, fullyReduced: Boolean): Behavior[Command] =
+    Behaviors.receiveMessage {
+      case Update(cellUpdates, replyTo) if !fullyReduced =>
+        val previousState = state
+        val updatedState = mergeState(state, cellUpdates)
+        if updatedState == previousState && cellUpdates != cellUpdatesEmpty then
+          replyTo ! SudokuDetailUnchanged
+          Behaviors.same
+        else
+          val transformedUpdatedState = updatedState.applyReductionRuleOne.applyReductionRuleTwo
+          if transformedUpdatedState == state then
+            replyTo ! SudokuDetailUnchanged
+            Behaviors.same
+          else
+            val updateSender = summon[UpdateSender[DetailType]]
+            updateSender.sendUpdate(id, stateChanges(state, transformedUpdatedState))(using replyTo)
+            operational(id, transformedUpdatedState, isFullyReduced(transformedUpdatedState))
+
+      case Update(_, replyTo) =>
+        replyTo ! SudokuDetailUnchanged
+        Behaviors.same
+
+      case GetSudokuDetailState(replyTo) =>
+        replyTo ! SudokuProgressTracker.SudokuDetailState(id, state)
+        Behaviors.same
+
+      case ResetSudokuDetailState =>
+        operational(id, InitialDetailState, fullyReduced = false)
+
+    }
+
+  private def mergeState(state: ReductionSet, cellUpdates: CellUpdates): ReductionSet =
+    cellUpdates.foldLeft(state) { case (stateTally, (index, updatedCellContent)) =>
+      stateTally.updated(index, stateTally(index) & updatedCellContent)
+    }
+
+  private def stateChanges(state: ReductionSet, updatedState: ReductionSet): CellUpdates =
+    state.zip(updatedState).zipWithIndex.foldRight(cellUpdatesEmpty) {
+      case (((previousCellContent, updatedCellContent), index), cellUpdates)
+          if updatedCellContent != previousCellContent =>
+        (index, updatedCellContent) +: cellUpdates
+
+      case (_, cellUpdates) => cellUpdates
+    }
+
+  private def isFullyReduced(state: ReductionSet): Boolean =
+    val allValuesInState = state.flatten
+    allValuesInState == allValuesInState.distinct

exercises/exercise_010_opaque_type_aliases/build.sbt renamed to exercises/exercise_010_exploring_opaque_type_aliases/build.sbt

@@ -0,0 +1,86 @@
+package org.lunatechlabs.dotty.sudoku
+
+import java.io.{BufferedReader, File, FileReader}
+import java.util.NoSuchElementException
+
+object SudokuIO:
+
+  private def sudokuCellRepresentation(content: CellContent): String =
+    content.toList match
+      case Nil                => "x"
+      case singleValue +: Nil => singleValue.toString
+      case _                  => " "
+
+  private def sudokuRowPrinter(threeRows: Vector[ReductionSet]): String =
+    val rowSubBlocks = for
+      row <- threeRows
+      rowSubBlock <- row.map(el => sudokuCellRepresentation(el)).sliding(3, 3)
+      rPres = rowSubBlock.mkString
+    yield rPres
+    rowSubBlocks.sliding(3, 3).map(_.mkString("", "|", "")).mkString("|", "|\n|", "|\n")
+
+  def sudokuPrinter(result: SudokuSolver.SudokuSolution): String =
+    result.sudoku.sliding(3, 3).map(sudokuRowPrinter).mkString("\n+---+---+---+\n", "+---+---+---+\n", "+---+---+---+")
+
+  /*
+   * FileLineTraversable code taken from "Scala in Depth" by Joshua Suereth
+   */
+
+  class FileLineTraversable(file: File) extends Iterable[String]:
+    val fr = new FileReader(file)
+    val input = new BufferedReader(fr)
+    var cachedLine: Option[String] = None
+    var finished: Boolean = false
+
+    override def iterator: Iterator[String] = new Iterator[String] {
+
+      override def hasNext: Boolean = (cachedLine, finished) match
+        case (Some(_), _) => true
+
+        case (None, true) => false
+
+        case (None, false) =>
+          try
+            val line = input.readLine()
+            if line == null then
+              finished = true
+              input.close()
+              fr.close()
+              false
+            else
+              cachedLine = Some(line)
+              true
+          catch
+            case e: java.io.IOError =>
+              throw new IllegalStateException(e.toString)
+
+      override def next(): String =
+        if !hasNext then throw new NoSuchElementException("No more lines in file")
+        val currentLine = cachedLine.get
+        cachedLine = None
+        currentLine
+    }
+    override def toString: String =
+      "{Lines of " + file.getAbsolutePath + "}"
+
+  def convertFromCellsToComplete(cellsIn: Vector[(String, Int)]): Vector[(Int, CellUpdates)] =
+    for
+      (rowCells, row) <- cellsIn
+      updates = rowCells.zipWithIndex.foldLeft(cellUpdatesEmpty) {
+        case (cellUpdates, (c, index)) if c != ' ' =>
+          (index, Set(c.toString.toInt)) +: cellUpdates
+        case (cellUpdates, _) => cellUpdates
+      }
+    yield (row, updates)
+
+  def readSudokuFromFile(sudokuInputFile: java.io.File): Vector[(Int, CellUpdates)] =
+    val dataLines = new FileLineTraversable(sudokuInputFile).toVector
+    val cellsIn =
+      dataLines
+        .map { inputLine => """\|""".r.replaceAllIn(inputLine, "") } // Remove 3x3 separator character
+        .filter(_ != "---+---+---") // Remove 3x3 line separator
+        .map("""^[1-9 ]{9}$""".r.findFirstIn(_)) // Input data should only contain values 1-9 or ' '
+        .collect { case Some(x) => x }
+        .zipWithIndex
+
+    convertFromCellsToComplete(cellsIn)

exercises/exercise_010_opaque_type_aliases/images/Markdown-viewer-IntelliJ.png renamed to exercises/exercise_010_exploring_opaque_type_aliases/images/Markdown-viewer-IntelliJ.png

@@ -0,0 +1,80 @@
+package org.lunatechlabs.dotty.sudoku
+
+private val N = 9
+val CellPossibleValues: Vector[Int] = (1 to N).toVector
+val cellIndexesVector: Vector[Int] = Vector.range(0, N)
+val initialCell: Set[Int] = Set.range(1, 10)
+val InitialDetailState = cellIndexesVector.map(_ => initialCell)
+
+type CellContent = Set[Int]
+type ReductionSet = Vector[CellContent]
+type Sudoku = Vector[ReductionSet]
+
+type CellUpdates = Vector[(Int, Set[Int])]
+val cellUpdatesEmpty = Vector.empty[(Int, Set[Int])]
+
+final case class SudokuField(sudoku: Sudoku)
+
+import SudokuDetailProcessor.RowUpdate
+
+extension (update: Vector[SudokuDetailProcessor.RowUpdate])
+  def toSudokuField: SudokuField =
+    import scala.language.implicitConversions
+    val rows =
+      update
+        .map { case SudokuDetailProcessor.RowUpdate(id, cellUpdates) => (id, cellUpdates) }
+        .to(Map)
+        .withDefaultValue(cellUpdatesEmpty)
+    val sudoku = for
+      (row, cellUpdates) <- Vector.range(0, 9).map(row => (row, rows(row)))
+      x = cellUpdates.to(Map).withDefaultValue(Set(0))
+      y = Vector.range(0, 9).map(n => x(n))
+    yield y
+    SudokuField(sudoku)
+
+// Collective Extensions:
+// define extension methods that share the same left-hand parameter type under a single extension instance.
+extension (sudokuField: SudokuField)
+
+  def mirrorOnMainDiagonal: SudokuField = SudokuField(sudokuField.sudoku.transpose)
+
+  def rotateCW: SudokuField = SudokuField(sudokuField.sudoku.reverse.transpose)
+
+  def rotateCCW: SudokuField = SudokuField(sudokuField.sudoku.transpose.reverse)
+
+  def flipVertically: SudokuField = SudokuField(sudokuField.sudoku.reverse)
+
+  def flipHorizontally: SudokuField = sudokuField.rotateCW.flipVertically.rotateCCW
+
+  def rowSwap(row1: Int, row2: Int): SudokuField =
+    SudokuField(sudokuField.sudoku.zipWithIndex.map {
+      case (_, `row1`) => sudokuField.sudoku(row2)
+      case (_, `row2`) => sudokuField.sudoku(row1)
+      case (row, _)    => row
+    })
+
+  def columnSwap(col1: Int, col2: Int): SudokuField =
+    sudokuField.rotateCW.rowSwap(col1, col2).rotateCCW
+
+  def randomSwapAround: SudokuField =
+    import scala.language.implicitConversions
+    val possibleCellValues = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9)
+    // Generate a random swapping of cell values. A value 0 is used as a marker for a cell
+    // with an unknown value (i.e. it can still hold all values 0 through 9). As such
+    // a cell with value 0 should remain 0 which is why we add an entry to the generated
+    // Map to that effect
+    val shuffledValuesMap =
+      possibleCellValues.zip(scala.util.Random.shuffle(possibleCellValues)).to(Map) + (0 -> 0)
+    SudokuField(sudokuField.sudoku.map { row =>
+      row.map(cell => Set(shuffledValuesMap(cell.head)))
+    })
+
+  def toRowUpdates: Vector[SudokuDetailProcessor.RowUpdate] =
+    sudokuField.sudoku
+      .map(_.zipWithIndex)
+      .map(row => row.filterNot(_._1 == Set(0)))
+      .zipWithIndex
+      .filter(_._1.nonEmpty)
+      .map { (c, i) =>
+        SudokuDetailProcessor.RowUpdate(i, c.map(_.swap))
+      }

exercises/exercise_010_opaque_type_aliases/project/Build.scala renamed to exercises/exercise_010_exploring_opaque_type_aliases/project/Build.scala

@@ -0,0 +1,16 @@
+package org.lunatechlabs.dotty.sudoku
+
+trait SudokuTestHelpers:
+
+  def stringToReductionSet(stringDef: Vector[String]): ReductionSet =
+    for {
+      cellString <- stringDef
+    } yield cellString.replaceAll(" ", "").map { _.toString.toInt }.toSet
+
+  def stringToIndexedUpdate(stringDef: Vector[String]): CellUpdates =
+    for {
+      (cellString, index) <- stringDef.zipWithIndex if cellString != ""
+    } yield (index, cellString.replaceAll(" ", "").map { _.toString.toInt }.toSet)
+
+  def applyReductionRules(reductionSet: ReductionSet): ReductionSet =
+    reductionSet.applyReductionRuleOne.applyReductionRuleTwo