Scala 隐式机制 —— 那些看起来像魔法的代码，到底在做什么

if (count.isEven()) doSomething()

implicit class MyRichInteger(n: Int) {
  def isEven() = n % 2 == 0
}

// 第二个参数列表用 implicit 标记，调用方可以省略
def calcTax(amount: Float)(implicit rate: Float): Float = amount * rate

object SimpleStateSalesTax {
  implicit val rate: Float = 0.05F   // 隐式值
}

import SimpleStateSalesTax.rate   // 引入到当前作用域
val amount = 100F
println(s"Tax on $amount = ${calcTax(amount)}")  // 5.0

case class ComplicatedSalesTaxData(
  baseRate: Float, isTaxHoliday: Boolean, storedId: Int)

object ComplicatedSalesTax {
  private def extractTaxRateForStore(id: Int): Float = 0.0F

  // rate 是个隐式 def，它需要另一个隐式参数 ComplicatedSalesTaxData
  implicit def rate(implicit cstd: ComplicatedSalesTaxData): Float =
    if (cstd.isTaxHoliday) 0.0F
    else cstd.baseRate + extractTaxRateForStore(cstd.storedId)
}

import ComplicatedSalesTax.rate
implicit val myStore = ComplicatedSalesTaxData(0.06F, false, 1010)

val amount = 100F
println(s"Tax on $amount = ${calcTax(amount)}")
// 编译器链式查找：先找 ComplicatedSalesTaxData，再找 ComplicatedSalesTax.rate

case class MyList[A](list: List[A]) {
  // 显式版本
  def sortBy1[B](f: A => B)(implicit ord: Ordering[B]): List[A] =
    list.sortBy(f)(ord)

  // 上下文界定的简化写法：[B: Ordering] = B 必须有一个 Ordering[B] 隐式值
  def sortBy2[B: Ordering](f: A => B): List[A] =
    list.sortBy(f)(implicitly[Ordering[B]])
  //              ^^^^^^^^
  //              implicitly[Ordering[B]] 是 stdlib 的"取隐式值"小工具
}

object TypeErasure {
  implicit object IntMarker       // 单例 object IntMarker
  implicit object StringMarker    // 单例 object StringMarker

  // 不同的隐式参数对象让编译器能在重载时区分 Seq[Int] 和 Seq[String]
  // 因为 JVM 把 Seq[Int] 和 Seq[String] 都擦成 Seq，类型本身区分不开
  def method(seq: Seq[Int])(implicit i: IntMarker.type): Unit =
    println(s"Seq[Int]: $seq")
  def method(seq: Seq[String])(implicit s: StringMarker.type): Unit =
    println(s"Seq[String]: $seq")
}

implicit class MyRichInteger(n: Int) {
  def isEven() = n % 2 == 0
}

println(23.isEven())  // 编译为 new MyRichInteger(23).isEven()，结果 true

object MyRichInteger {
  implicit def MyRichInteger(n: Int): MyRichInteger = new MyRichInteger(n)
}

// 给 Any 类型加 stringize 方法
implicit class AnyStringizer(any: Any) extends Stringizer[Any] {
  override def stringize: String = any match {
    case s: String => s
    case i: Int    => (i * 10).toString
    case f: Float  => (f * 10.1).toString
    case other     => throw new UnsupportedOperationException(s"Can't stringize $other")
  }
}

// 1. "能力"接口：谁具备 toJson 能力
trait ToJson {
  def toJson(level: Int = 0): String
  val INDENTATION = " "
  def indentation(level: Int = 0) =
    (INDENTATION * level, INDENTATION * (level + 1))
}

// 2. 给 Address 注入 toJson 能力（implicit class 形式）
implicit class AddressToJson(address: Address) extends ToJson {
  override def toJson(level: Int): String = {
    val (outdent, indent) = indentation(level)
    s"""{
       |${indent}"street": "${address.street}"
       |${indent}"city":   "${address.city}"
       |$outdent}""".stripMargin
  }
}

// 3. 给 Person 注入 toJson 能力，并且 Person 内部能调用 address.toJson
implicit class PersonToJson(person: Person) extends ToJson {
  override def toJson(level: Int): String = {
    val (outdent, indent) = indentation(level)
    s"""{
       |${indent}"name":    "${person.name}",
       |${indent}"address": ${person.address.toJson(level + 1)}
       |$outdent}""".stripMargin
  }
}

val address = Address("1 scala lane", "anytown")
val person = Person("Buck Treeds", address)
println(person.toJson())
// Person 类本身没有 toJson 方法，是 PersonToJson 这个 implicit class 给它注入的

// 员工信息
case class Employee(
  name: String,
  annualSalary: Float,
  taxRate: Float,
  insurancePremiumsPerPayPeriod: Float,
  _401kDeductionRate: Float,
  postTaxDeductionRates: Float)

// 工资 + "状态标签" Step（phantom type，不存储任何字段）
case class Pay[Step](employee: Employee, netPay: Float)

// 三个状态标签
case class PreTaxDeductions()    // 税前扣款状态
case class PostTaxDeductions()   // 税后扣款状态
case class Final()               // 最终状态

object Payroll {
  // start 返回 Pay[PreTaxDeductions]
  def start(employee: Employee): Pay[PreTaxDeductions] =
    Pay[PreTaxDeductions](employee, employee.annualSalary / 26.0F)

  // minusInsurance / minus401k 在 PreTaxDeductions 状态上工作，仍返回 PreTaxDeductions
  def minusInsurance(pay: Pay[PreTaxDeductions]): Pay[PreTaxDeductions] = {
    val newNet = pay.netPay - pay.employee.insurancePremiumsPerPayPeriod
    pay copy (netPay = newNet)
  }

  def minus401k(pay: Pay[PreTaxDeductions]): Pay[PreTaxDeductions] = {
    val newNet = pay.netPay - (pay.employee._401kDeductionRate * pay.netPay)
    pay copy (netPay = newNet)
  }

  // minusTax 把 PreTaxDeductions 转换为 PostTaxDeductions
  def minusTax(pay: Pay[PreTaxDeductions]): Pay[PostTaxDeductions] = {
    val newNet = pay.netPay - (pay.employee.taxRate * pay.netPay)
    pay copy (netPay = newNet)
  }

  // minusFinalDeductions 只接受 PostTaxDeductions，返回 Final
  def minusFinalDeductions(pay: Pay[PostTaxDeductions]): Pay[Final] = {
    val newNet = pay.netPay - pay.employee.postTaxDeductionRates
    pay copy (netPay = newNet)
  }
}

object Pipeline {
  // 用 implicit class 给任意值加 |> 管道操作符
  implicit class toPiped[V](value: V) {
    def |>[R](f: V => R) = f(value)   // 等价于 f(value)
  }
}

val payPipeline = start(employee) |>
  minus401k |>
  minusInsurance |>
  minusTax |>
  minusFinalDeductions

// 假设有个 Java 类 JavaRow 提供 getInt/getDouble/getText 三个方法
class JavaRow {
  def getInt(colName: String): Int = ???
  def getDouble(colName: String): Double = ???
  def getText(colName: String): String = ???
}

object implicits {
  // 1. 给 JavaRow 注入一个 get[T] 方法
  implicit class ScalaRow(javaRow: JavaRow) {
    def get[T](colName: String)(implicit toT: (JavaRow, String) => T): T =
      toT(javaRow, colName)
  }

  // 2. 三个"目标类型 → 转换函数"的隐式值
  implicit val jrowToInt:    (JavaRow, String) => Int    = (r, c) => r.getInt(c)
  implicit val jrowToDouble: (JavaRow, String) => Double = (r, c) => r.getDouble(c)
  implicit val jrowToString: (JavaRow, String) => String = (r, c) => r.getText(c)
}

import implicits._

val row = JRow("one" -> 1, "two" -> 2.2, "three" -> "THREE!")
//      ^^^^ 工厂方法，把 (key, value) 对构造成 JavaRow

val oneValue: Int    = row.get[Int]("one")
// 编译器看到期望类型 Int，找 implicit (JavaRow, String) => Int，填给 toT
val twoValue: Double = row.get[Double]("two")
val threeValue: String = row.get[String]("three")

val comparison: _1 < _3 = <[_1, _3]