Scala函数式模式Skill ScalaFunctionalPatterns

---

name: Scala 函数式模式 user-invocable: false description: 当在Scala中使用函数式编程模式时，包括高阶函数、不可变性、模式匹配、代数数据类型、单子、for-推导和函数组合，用于构建健壮、类型安全的应用程序。 allowed-tools: []

Scala 函数式模式

介绍

Scala 独特地融合了面向对象和函数式编程范式，使开发者能够利用两者的优势。Scala 中的函数式编程强调不可变性、纯函数和可组合性，从而产生更可预测和可维护的代码。

Scala 的核心函数式模式包括高阶函数、不可变数据结构、模式匹配、代数数据类型（ADTs）、单子组合、for-推导和类型类。这些模式能够在保持类型安全的同时，为复杂问题提供优雅的解决方案。

本技能涵盖不可变性原则、高阶函数、模式匹配、使用密封特质的ADTs、Option和Either单子、for-推导、函数组合和函数式错误处理。

不可变性和纯函数

不可变数据结构和纯函数构成了函数式编程的基础，确保可预测的行为和线程安全。

// 不可变案例类
case class User(
  id: Int,
  name: String,
  email: String,
  age: Int
)

// 复制并修改
val user = User(1, "Alice", "alice@example.com", 30)
val updatedUser = user.copy(age = 31)

// 不可变集合
val numbers = List(1, 2, 3, 4, 5)
val doubled = numbers.map(_ * 2)  // 原列表不变

// 纯函数（确定性，无副作用）
def add(a: Int, b: Int): Int = a + b

def multiply(a: Int, b: Int): Int = a * b

def calculateTotal(price: Double, quantity: Int, discount: Double): Double = {
  val subtotal = price * quantity
  val discountAmount = subtotal * discount
  subtotal - discountAmount
}

// 非纯函数（副作用：日志记录）
def impureAdd(a: Int, b: Int): Int = {
  println(s"Adding $a and $b")  // 副作用
  a + b
}

// 分离纯逻辑和副作用
def pureCalculation(items: List[Double]): Double =
  items.sum

def displayResult(result: Double): Unit =
  println(s"Total: $result")

val items = List(10.0, 20.0, 30.0)
val total = pureCalculation(items)
displayResult(total)

// 不可变数据转换
case class Order(items: List[String], total: Double)

def addItem(order: Order, item: String, price: Double): Order =
  order.copy(
    items = order.items :+ item,
    total = order.total + price
  )

def applyDiscount(order: Order, percentage: Double): Order =
  order.copy(total = order.total * (1 - percentage))

// 组合不可变转换
val order = Order(List("Book"), 25.0)
val finalOrder = applyDiscount(addItem(order, "Pen", 5.0), 0.1)

// 不可变构建器模式
case class PersonBuilder(
  name: Option[String] = None,
  age: Option[Int] = None,
  email: Option[String] = None
) {
  def withName(n: String): PersonBuilder = copy(name = Some(n))
  def withAge(a: Int): PersonBuilder = copy(age = Some(a))
  def withEmail(e: String): PersonBuilder = copy(email = Some(e))

  def build: Option[Person] = for {
    n <- name
    a <- age
    e <- email
  } yield Person(n, a, e)
}

case class Person(name: String, age: Int, email: String)

val person = PersonBuilder()
  .withName("Bob")
  .withAge(25)
  .withEmail("bob@example.com")
  .build

不可变性消除了与共享可变状态相关的整个类别的错误，并支持安全的并发编程。

高阶函数

高阶函数接受函数作为参数或返回函数，实现强大的抽象和代码重用。

// 函数作为参数
def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int =
  op(x, y)

val sum = applyOperation(5, 3, (a, b) => a + b)
val product = applyOperation(5, 3, (a, b) => a * b)

// 函数作为返回值
def multiplyBy(factor: Int): Int => Int =
  (x: Int) => x * factor

val double = multiplyBy(2)
val triple = multiplyBy(3)

println(double(5))  // 10
println(triple(5))  // 15

// 柯里化
def curriedAdd(a: Int)(b: Int): Int = a + b

val add5 = curriedAdd(5) _
println(add5(3))  // 8

// 部分应用
def greet(greeting: String, name: String): String =
  s"$greeting, $name!"

val sayHello: String => String = greet("Hello", _)
println(sayHello("Alice"))  // Hello, Alice!

// 函数组合
val addOne: Int => Int = _ + 1
val multiplyByTwo: Int => Int = _ * 2

val addThenMultiply = addOne andThen multiplyByTwo
val multiplyThenAdd = addOne compose multiplyByTwo

println(addThenMultiply(5))   // (5 + 1) * 2 = 12
println(multiplyThenAdd(5))   // (5 * 2) + 1 = 11

// 使用高阶函数的集合操作
val numbers = List(1, 2, 3, 4, 5)

val squared = numbers.map(x => x * x)
val evens = numbers.filter(_ % 2 == 0)
val sum = numbers.reduce(_ + _)
val product = numbers.fold(1)(_ * _)

// FlatMap用于嵌套转换
val nested = List(List(1, 2), List(3, 4), List(5))
val flattened = nested.flatMap(identity)

val pairs = numbers.flatMap(x => numbers.map(y => (x, y)))

// 自定义高阶函数
def retry[T](times: Int)(operation: => T): Option[T] = {
  @scala.annotation.tailrec
  def attempt(remaining: Int): Option[T] = {
    if (remaining <= 0) None
    else {
      try {
        Some(operation)
      } catch {
        case _: Exception => attempt(remaining - 1)
      }
    }
  }
  attempt(times)
}

def withLogging[T](name: String)(operation: => T): T = {
  println(s"Starting $name")
  val result = operation
  println(s"Finished $name")
  result
}

// 测量执行时间
def timed[T](operation: => T): (T, Long) = {
  val start = System.nanoTime()
  val result = operation
  val elapsed = System.nanoTime() - start
  (result, elapsed / 1000000)  // 转换为毫秒
}

val (result, time) = timed {
  (1 to 1000000).sum
}
println(s"Result: $result, Time: ${time}ms")

高阶函数实现强大的抽象，允许捕获常见模式并消除代码重复。

模式匹配

模式匹配提供优雅的语法用于条件逻辑和数据提取，远比传统的switch语句强大。

// 基本模式匹配
def describe(x: Any): String = x match {
  case 0 => "zero"
  case 1 => "one"
  case i: Int => s"integer: $i"
  case s: String => s"string: $s"
  case _ => "unknown"
}

// 带守卫的模式匹配
def classify(x: Int): String = x match {
  case n if n < 0 => "negative"
  case 0 => "zero"
  case n if n > 0 && n < 10 => "small positive"
  case n if n >= 10 => "large positive"
}

// 解构案例类
case class Point(x: Int, y: Int)

def locationDescription(point: Point): String = point match {
  case Point(0, 0) => "origin"
  case Point(0, y) => s"on Y-axis at $y"
  case Point(x, 0) => s"on X-axis at $x"
  case Point(x, y) if x == y => s"on diagonal at ($x, $y)"
  case Point(x, y) => s"at ($x, $y)"
}

// 列表模式匹配
def sumList(list: List[Int]): Int = list match {
  case Nil => 0
  case head :: tail => head + sumList(tail)
}

def describeList[T](list: List[T]): String = list match {
  case Nil => "empty"
  case _ :: Nil => "single element"
  case _ :: _ :: Nil => "two elements"
  case _ :: _ :: _ :: _ => "three or more elements"
}

// 模式中的变量绑定
def processMessage(msg: Any): String = msg match {
  case s: String if s.length > 10 => s"Long string: ${s.take(10)}..."
  case s @ String => s"String: $s"
  case n @ (_: Int | _: Double) => s"Number: $n"
  case _ => "Unknown type"
}

// Option模式匹配
def getUserName(userId: Int): Option[String] = {
  if (userId > 0) Some(s"User$userId") else None
}

def displayUserName(userId: Int): String = getUserName(userId) match {
  case Some(name) => s"Welcome, $name"
  case None => "User not found"
}

// Either模式匹配
def divide(a: Int, b: Int): Either[String, Double] =
  if (b == 0) Left("Division by zero")
  else Right(a.toDouble / b)

def describeDivision(result: Either[String, Double]): String = result match {
  case Left(error) => s"Error: $error"
  case Right(value) => s"Result: $value"
}

// 元组模式匹配
def processPair(pair: (String, Int)): String = pair match {
  case (name, age) if age < 18 => s"$name is a minor"
  case (name, age) => s"$name is $age years old"
}

// 嵌套模式匹配
sealed trait Tree[+T]
case class Leaf[T](value: T) extends Tree[T]
case class Branch[T](left: Tree[T], right: Tree[T]) extends Tree[T]

def depth[T](tree: Tree[T]): Int = tree match {
  case Leaf(_) => 1
  case Branch(left, right) => 1 + Math.max(depth(left), depth(right))
}

// 在for-推导中的模式匹配
val tuples = List((1, "one"), (2, "two"), (3, "three"))

val result = for {
  (num, word) <- tuples
  if num % 2 != 0
} yield s"$num: $word"

模式匹配使代码更可读和详尽，编译器确保密封类型的所有情况都被覆盖。

代数数据类型（ADTs）

ADTs使用密封特质和案例类建模数据，实现详尽的模式匹配和类型安全的领域建模。

// 结果的简单ADT
sealed trait Result[+T]
case class Success[T](value: T) extends Result[T]
case class Failure(error: String) extends Result[Nothing]

def processResult[T](result: Result[T]): String = result match {
  case Success(value) => s"Success: $value"
  case Failure(error) => s"Failure: $error"
}

// 支付方法的ADT
sealed trait PaymentMethod
case class CreditCard(number: String, cvv: String) extends PaymentMethod
case class PayPal(email: String) extends PaymentMethod
case class BankTransfer(accountNumber: String) extends PaymentMethod

def processPayment(method: PaymentMethod, amount: Double): String =
  method match {
  case CreditCard(number, _) => s"Charging $$${amount} to card ending in ${number.takeRight(4)}"
  case PayPal(email) => s"Charging $$${amount} via PayPal account $email"
  case BankTransfer(account) => s"Transferring $$${amount} from account $account"
}

// 列表的递归ADT
sealed trait MyList[+T]
case object MyNil extends MyList[Nothing]
case class Cons[T](head: T, tail: MyList[T]) extends MyList[T]

def length[T](list: MyList[T]): Int = list match {
  case MyNil => 0
  case Cons(_, tail) => 1 + length(tail)
}

// 表达式树的ADT
sealed trait Expr
case class Num(value: Double) extends Expr
case class Add(left: Expr, right: Expr) extends Expr
case class Multiply(left: Expr, right: Expr) extends Expr
case class Divide(left: Expr, right: Expr) extends Expr

def evaluate(expr: Expr): Either[String, Double] = expr match {
  case Num(value) => Right(value)
  case Add(left, right) => for {
    l <- evaluate(left)
    r <- evaluate(right)
  } yield l + r
  case Multiply(left, right) => for {
    l <- evaluate(left)
    r <- evaluate(right)
  } yield l * r
  case Divide(left, right) => for {
    l <- evaluate(left)
    r <- evaluate(right)
    result <- if (r != 0) Right(l / r) else Left("Division by zero")
  } yield result
}

// 示例用法
val expr = Divide(Add(Num(10), Num(5)), Multiply(Num(3), Num(2)))
println(evaluate(expr))  // Right(2.5)

// JSON的ADT
sealed trait Json
case object JNull extends Json
case class JBoolean(value: Boolean) extends Json
case class JNumber(value: Double) extends Json
case class JString(value: String) extends Json
case class JArray(values: List[Json]) extends Json
case class JObject(fields: Map[String, Json]) extends Json

def stringify(json: Json): String = json match {
  case JNull => "null"
  case JBoolean(value) => value.toString
  case JNumber(value) => value.toString
  case JString(value) => s""""$value""""
  case JArray(values) => values.map(stringify).mkString("[", ",", "]")
  case JObject(fields) =>
    fields.map { case (k, v) => s""""$k":${stringify(v)}""" }
      .mkString("{", ",", "}")
}

// 使用ADT的状态机
sealed trait ConnectionState
case object Disconnected extends ConnectionState
case object Connecting extends ConnectionState
case object Connected extends ConnectionState
case object Disconnecting extends ConnectionState

def transition(state: ConnectionState, event: String): ConnectionState =
  (state, event) match {
    case (Disconnected, "connect") => Connecting
    case (Connecting, "connected") => Connected
    case (Connected, "disconnect") => Disconnecting
    case (Disconnecting, "disconnected") => Disconnected
    case (current, _) => current  // 无效转换
  }

ADTs提供详尽的模式匹配保证，并在编译时使非法状态不可表示。

Option和Either单子

Option和Either提供函数式错误处理，无需异常，实现可组合的错误处理。

// Option用于可空值
def findUser(id: Int): Option[User] =
  if (id > 0) Some(User(id, "Alice", "alice@example.com", 30))
  else None

// Option操作
val maybeUser = findUser(1)

val name = maybeUser.map(_.name).getOrElse("Unknown")
val email = maybeUser.flatMap(u => Some(u.email))

// Option链式调用
def getAddress(user: User): Option[String] = Some("123 Main St")
def getCity(address: String): Option[String] = Some("Springfield")

val city = for {
  user <- findUser(1)
  address <- getAddress(user)
  city <- getCity(address)
} yield city

// Either用于错误处理
def parseInt(s: String): Either[String, Int] =
  try Right(s.toInt)
  catch { case _: NumberFormatException => Left(s"'$s' is not a valid integer") }

def divide(a: Int, b: Int): Either[String, Double] =
  if (b == 0) Left("Division by zero")
  else Right(a.toDouble / b)

// Either组合
def calculate(a: String, b: String): Either[String, Double] = for {
  x <- parseInt(a)
  y <- parseInt(b)
  result <- divide(x, y)
} yield result

println(calculate("10", "2"))   // Right(5.0)
println(calculate("10", "0"))   // Left(Division by zero)
println(calculate("ten", "2"))  // Left('ten' is not a valid integer)

// 组合多个Options
def combineOptions(a: Option[Int], b: Option[Int], c: Option[Int]): Option[Int] =
  for {
    x <- a
    y <- b
    z <- c
  } yield x + y + z

// 处理Option集合
val options = List(Some(1), None, Some(3), Some(4))

val flattened = options.flatten  // List(1, 3, 4)
val sumOfSomes = options.flatten.sum  // 8

// Option和Either之间的转换
def optionToEither[T](opt: Option[T], error: String): Either[String, T] =
  opt.toRight(error)

def eitherToOption[T](either: Either[String, T]): Option[T] =
  either.toOption

// 使用Either进行验证
case class ValidationError(field: String, message: String)

def validateEmail(email: String): Either[ValidationError, String] =
  if (email.contains("@")) Right(email)
  else Left(ValidationError("email", "Invalid email format"))

def validateAge(age: Int): Either[ValidationError, Int] =
  if (age >= 18) Right(age)
  else Left(ValidationError("age", "Must be 18 or older"))

def validateUser(email: String, age: Int):
  Either[List[ValidationError], User] = {
  val emailResult = validateEmail(email)
  val ageResult = validateAge(age)

  (emailResult, ageResult) match {
    case (Right(e), Right(a)) => Right(User(1, "User", e, a))
    case (Left(e1), Left(e2)) => Left(List(e1, e2))
    case (Left(e), _) => Left(List(e))
    case (_, Left(e)) => Left(List(e))
  }
}

// Try用于异常处理
import scala.util.{Try, Success, Failure}

def safeDivide(a: Int, b: Int): Try[Double] =
  Try(a.toDouble / b)

val tryResult = safeDivide(10, 2) match {
  case Success(value) => s"Result: $value"
  case Failure(exception) => s"Error: ${exception.getMessage}"
}

// Try转换为Either
def tryToEither[T](tried: Try[T]): Either[Throwable, T] =
  tried.toEither

Option和Either消除空指针异常，并使错误处理在函数签名中显式化。

For-推导

For-推导为单子操作提供语法糖，使顺序计算更可读。

// 基本for-推导
val result = for {
  x <- List(1, 2, 3)
  y <- List(10, 20)
} yield x + y

// 带过滤
val evens = for {
  x <- 1 to 10
  if x % 2 == 0
} yield x

// 嵌套for-推导
val pairs = for {
  x <- 1 to 3
  y <- 1 to 3
  if x < y
} yield (x, y)

// 使用Option
def getUserById(id: Int): Option[User] =
  Some(User(id, "Alice", "alice@example.com", 30))
def getOrdersByUser(user: User): Option[List[Order]] =
  Some(List(Order(List("Book"), 25.0)))

val totalOrders = for {
  user <- getUserById(1)
  orders <- getOrdersByUser(user)
} yield orders.length

// 使用Either
def validateInput(input: String): Either[String, Int] =
  if (input.isEmpty) Left("Input is empty")
  else if (input.toIntOption.isEmpty) Left("Not a number")
  else Right(input.toInt)

def processValue(value: Int): Either[String, Int] =
  if (value < 0) Left("Value must be positive")
  else Right(value * 2)

val processed = for {
  input <- validateInput("10")
  doubled <- processValue(input)
} yield doubled

// 使用for-推导的并行组合
case class UserProfile(user: User, orders: List[Order], friends: List[User])

def getUserProfile(userId: Int): Option[UserProfile] = for {
  user <- getUserById(userId)
  orders <- getOrdersByUser(user)
  friends <- getFriendsByUser(user)
} yield UserProfile(user, orders, friends)

def getFriendsByUser(user: User): Option[List[User]] = Some(List())

// For-推导与Future
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

def fetchUser(id: Int): Future[User] =
  Future(User(id, "Alice", "alice@example.com", 30))

def fetchOrders(user: User): Future[List[Order]] =
  Future(List(Order(List("Book"), 25.0)))

val userWithOrders: Future[(User, List[Order])] = for {
  user <- fetchUser(1)
  orders <- fetchOrders(user)
} yield (user, orders)

// For-推导的去糖化
val manual = List(1, 2, 3)
  .flatMap(x => List(10, 20).map(y => x + y))

val withFor = for {
  x <- List(1, 2, 3)
  y <- List(10, 20)
} yield x + y

// 两者产生相同结果

For-推导使单子组合可读，并消除异步代码中的回调嵌套。

函数组合和组合子

函数组合从简单函数创建复杂函数，促进可重用性和模块性。

// 基本组合
val addOne: Int => Int = _ + 1
val double: Int => Int = _ * 2
val square: Int => Int = x => x * x

val addOneThenDouble = addOne andThen double
val doubleBeforeAddOne = addOne compose double

println(addOneThenDouble(3))    // (3 + 1) * 2 = 8
println(doubleBeforeAddOne(3))  // (3 * 2) + 1 = 7

// 函数组合子
def constant[A, B](b: B): A => B = _ => b

def identity[A]: A => A = a => a

def compose[A, B, C](f: B => C, g: A => B): A => C =
  a => f(g(a))

// 提升函数
def lift[A, B](f: A => B): Option[A] => Option[B] =
  _.map(f)

val lifted = lift(addOne)
println(lifted(Some(5)))  // Some(6)
println(lifted(None))     // None

// Kleisli组合（组合单子函数）
def kleisli[A, B, C](f: A => Option[B], g: B => Option[C]): A => Option[C] =
  a => f(a).flatMap(g)

def safeDivideBy(divisor: Int): Int => Option[Int] =
  n => if (divisor != 0) Some(n / divisor) else None

def validatePositive(n: Int): Option[Int] =
  if (n > 0) Some(n) else None

val composed = kleisli(safeDivideBy(2), validatePositive)
println(composed(10))  // Some(5)
println(composed(3))   // None（除法后不为正）

// Reader单子用于依赖注入
case class Config(apiUrl: String, timeout: Int)

type Reader[A] = Config => A

def getApiUrl: Reader[String] = config => config.apiUrl
def getTimeout: Reader[Int] = config => config.timeout

def buildRequest: Reader[String] = for {
  url <- getApiUrl
  timeout <- getTimeout
} yield s"Request to $url with timeout $timeout"

val config = Config("https://api.example.com", 5000)
println(buildRequest(config))

// 应用函子
def map2[A, B, C](fa: Option[A], fb: Option[B])(f: (A, B) => C): Option[C] =
  for {
    a <- fa
    b <- fb
  } yield f(a, b)

val result1 = map2(Some(2), Some(3))(_ + _)  // Some(5)
val result2 = map2(Some(2), None: Option[Int])(_ + _)  // None

// 遍历
def traverse[A, B](list: List[A])(f: A => Option[B]): Option[List[B]] =
  list.foldRight(Some(Nil): Option[List[B]]) { (a, acc) =>
    map2(f(a), acc)(_ :: _)
  }

val numbers = List("1", "2", "3")
println(traverse(numbers)(s => s.toIntOption))  // Some(List(1, 2, 3))

函数组合允许从简单、可测试的组件构建复杂操作。

最佳实践

1. 优先使用不可变数据结构，以消除与共享可变状态相关的整个类别错误。

2. 使用密封特质定义ADTs，以实现详尽的模式匹配和编译时保证。

3. 利用for-推导进行单子组合，而不是嵌套flatMap调用。

4. 显式化副作用，通过分离纯计算和IO操作。

5. 使用Option代替null，使可空值在类型签名中显式化。

6. 优先使用Either进行错误处理，而非异常，使错误情况显式化。

7. 组合函数，而非编写大型单块函数，以提高可重用性。

8. 使用尾递归并添加@tailrec注解，以防止递归函数的栈溢出。

9. 利用类型推断，但为公共API和复杂表达式提供显式类型。

10. 应用部分应用和柯里化，从通用函数创建专用函数。

常见陷阱

1. 混合可变和不可变集合，导致意外修改和错误。

2. 过度使用var代替val，削弱不可变性优势，使代码更难推理。

3. 不处理Option中的None情况，导致类型安全下的运行时失败。

4. 捕获所有异常，而不是使用Try、Either或Option，丢失类型安全优势。

5. 创建非尾递归函数处理大输入，导致栈溢出错误。

6. 不将ADTs设为密封，允许在其他地方添加案例，破坏模式匹配的详尽性。

7. 嵌套flatMap调用，而不是使用for-推导，显著降低可读性。

8. 使用null代替Option，违背函数式错误处理的目的。

9. 创建非纯函数而不记录副作用，使代码不可预测。

10. 过早使用高阶类型进行过度抽象，增加复杂性而无明确好处。

何时使用此技能

在整个Scala开发过程中应用函数式模式，以利用语言优势并构建可维护系统。

在构建业务逻辑时使用不可变性和纯函数，以确保可预测性和可测试性。

在建模具有不同状态或变体的领域实体时，利用模式匹配和ADTs。

在API和服务层应用Option和Either进行错误处理，使错误情况显式化。

在组合多个单子操作时使用for-推导，以提高可读性。

在构建数据转换管道或可重用实用函数时，采用函数组合。

资源

• Scala中的函数式编程
• Scala文档 - 模式匹配
• Scala与Cats
• Scala函数式编程原理（Coursera）
• Herding Cats - Cats教程