Scala 函数式编程实战：不可变、纯函数、高阶函数与 Option

// ❌ 不纯：读/写了外部状态
var cache: Map[String, Int] = Map.empty
def slowAdd(a: Int, b: Int): Int = {
  val key = s"$a+$b"
  cache.getOrElse(key, { val r = a + b; cache += key -> r; r })
}

// ✅ 纯：不依赖也不修改外部状态
def add(a: Int, b: Int): Int = a + b

val nums = List(1, 2, 3)        // 不可变，add 返回新 List
val doubled = nums.map(_ * 2)   // List(2,4,6)

val addOne: Int => Int = (x: Int) => x + 1
val addTwo = (x: Int) => x + 2

def applyTwice(f: Int => Int, x: Int): Int = f(f(x))
applyTwice(addOne, 5)      // 7

List(1,2,3).map(_ * 2)                 // 逐个变换
List(1,2,3,4).filter(_ % 2 == 0)       // 按条件保留
List(1,2,3).reduceLeft(_ + _)          // 两两归并

def isEven(x: Int): Boolean = x % 2 == 0
val f: Int => Boolean = isEven _      // 方法提升为函数
List(1,2,3,4).filter(f)               // List(2,4)

val words = List("hello", "world")
words.map(_.toUpperCase)              // List("HELLO","WORLD")
words.flatMap(_.toList)               // 拆成字符并拍平：List(h,e,l,l,o,...)

List(1,2,3,4).foldLeft(0)(_ + _)      // 10，从左累积
List(1,2,3,4).foldLeft(1)(_ * _)      // 24

val a = List(1, 2)
val b = List(3, 4)

// 等价写法 1：flatMap 嵌套
val r1 = a.flatMap(x => b.map(y => (x, y)))

// 等价写法 2：for 推导式（更可读）
val r2 = for {
  x <- a
  y <- b
} yield (x, y)
// 两者都得到 List((1,3),(1,4),(2,3),(2,4))

def findUser(id: Int): Option[User] =
  if (id > 0) Some(User(id)) else None

findUser(1) match {
  case Some(u) => s"找到: $u"
  case None    => "未找到"
}

// 避免层层 if-null
val result = findUser(1)
  .flatMap(u => u.email)          // 可能没有 email
  .map(e => e.toLowerCase)
  .getOrElse("no-email")

// 约定：Left 是错误，Right 是成功
def parseAge(s: String): Either[String, Int] =
  s.toIntOption.map(Right(_)).getOrElse(Left(s"无法解析: $s"))

parseAge("30")  // Right(30)
parseAge("abc") // Left("无法解析: abc")

def describe(x: Any): String = x match {
  case i: Int    if i > 0 => "正整数"
  case i: Int             => "非正整数"
  case s: String          => s"字符串: $s"
  case List(a, b, _*)     => s"列表，前两个: $a, $b"
  case _                  => "未知"
}

case class Order(id: Long, amount: Double)

def fee(o: Order): Double = o match {
  case Order(_, a) if a > 1000 => a * 0.01   // 解构出 amount
  case _                       => 0.0
}

val double = (x: Int) => x * 2
val inc    = (x: Int) => x + 1

val doubleThenInc = inc.compose(double)   // 先 double 再 inc
val incThenDouble = inc.andThen(double)   // 先 inc 再 double

doubleThenInc(3)  // 7
incThenDouble(3)  // 8

// 把一次数据处理写成一段「管道」
val pipeline = List(1,2,3,4,5)
  .filter(_ > 2)          // 过滤
  .map(_ * 10)            // 放大
  .foldLeft(0)(_ + _)     // 累加
// = (30 + 40 + 50) = 120

// 泛型序列化：调用方无需显式传序列化器
trait Serializer[T] { def serialize(t: T): String }

given intSerializer: Serializer[Int] =
  (t: Int) => t.toString

def toJson[T](t: T)(using s: Serializer[T]): String =
  s.serialize(t)

toJson(42)   // 自动找 implicit Serializer[Int]

// 第1步：命令式（Java 风格）
def sumEven(list: List[Int]): Int = {
  var acc = 0
  for (x <- list) {
    if (x % 2 == 0) acc += x
  }
  acc
}

// 第2步：逐步函数式
def sumEven2(list: List[Int]): Int =
  list.filter(_ % 2 == 0).foldLeft(0)(_ + _)

// 第3步：组合成纯表达式
val sumEven3 = (list: List[Int]) =>
  list.filter(_ % 2 == 0).sum