Composition, Export & Self Types

//> using scala 3.10.0

class Printer:
  def print(bits: Int): String = s"bits=$bits"
  def print(text: String): String = s"text=$text"
  def status: String = "idle"
  def reset(): Unit = println("reset")
  val model = "P-1"

class Scanner:
  def scan(): String = "scanned"
  def status: String = "ready"

class Copier:
  private val printUnit = Printer()
  private val scanUnit = Scanner()
  export printUnit.{status as printerStatus, print as _, *}
  export scanUnit.scan
  export printUnit.print          // both overloads
  export scanUnit.{status as scannerStatus}

@main def e2(): Unit =
  val c = Copier()
  println(c.printerStatus)
  println(c.scannerStatus)
  println(c.print(3))
  println(c.print("x"))
  println(c.model)
  println(c.scan())

idle
ready
bits=3
text=x
P-1
scanned

//> using scala 3.10.0

trait Cmp[T]:
  def cmp(a: T, b: T): Int
object Instances:
  given Cmp[Int] = (a, b) => a - b
  def helper = 1

object Plain:
  export Instances.*        // the given is not exported
object WithGiven:
  export Instances.given    // only givens

@main def e18(): Unit =
  println(Plain.helper)
  import WithGiven.given
  println(summon[Cmp[Int]].cmp(3, 1))

1
2

//> using scala 3.10.0

class TextOps(x: String):
  def shout: String = x.toUpperCase + "!"
  def twice: String = x + x

extension (x: String)
  def firstWord: String = x.takeWhile(_ != ' ')
  private def moreOps = TextOps(x)
  export moreOps.*

@main def e16(): Unit =
  println("rock climbing".firstWord)
  println("hut".shout)
  println("ab".twice)

rock
HUT!
abab

-- [E003] Syntax Error: e20.scala:5:10
5 |  this: A with B =>
  |          ^^^^
  |with as a type operator has been deprecated; use & instead
  |This construct can be rewritten automatically under -rewrite -source 3.4-migration.

//> using scala 3.10.0

// OOP style module: a trait with abstract members, a class with the implementation
trait TrailRepository:
  def names: List[String]

trait TrailService:
  def longest: String

class InMemoryRepository extends TrailRepository:
  def names = List("Aguja", "Ordesa", "Cares")

// constructor injection
class DefaultService(repo: TrailRepository) extends TrailService:
  def longest = repo.names.maxBy(_.length)

// FP style module: an object with plain functions over immutable data
object Trails:
  final case class Trail(name: String, km: Double)
  def total(ts: List[Trail]): Double = ts.map(_.km).sum
  def longest(ts: List[Trail]): Option[Trail] = ts.maxByOption(_.km)

@main def e12(): Unit =
  val svc: TrailService = DefaultService(InMemoryRepository())
  println(svc.longest)
  val ts = List(Trails.Trail("Aguja", 7.5), Trails.Trail("Cares", 12.0))
  println(Trails.total(ts))
  println(Trails.longest(ts))

Ordesa
19.5
Some(Trail(Cares,12.0))

//> using scala 3.10.0

trait Storage:
  def load(): List[String]
trait Notifier:
  def send(msg: String): Unit

// each service is a trait; the concrete module assembles them with export
class StorageImpl extends Storage:
  def load() = List("Aguja", "Cares")
class NotifierImpl extends Notifier:
  def send(msg: String) = println(s"notify: $msg")

class HikeModule:
  private val storage = StorageImpl()
  private val notifier = NotifierImpl()
  export storage.load
  export notifier.send

// a self-type "cake" assembly, for contrast
trait StorageComponent:
  def storage: Storage
trait PlannerComponent:
  this: StorageComponent =>
  def firstTrail: String = storage.load().head

object Cake extends PlannerComponent, StorageComponent:
  val storage = StorageImpl()

@main def e13(): Unit =
  val m = HikeModule()
  m.send(m.load().mkString(","))
  println(Cake.firstTrail)

notify: Aguja,Cares
Aguja