严格语言中Monad并非必需？解析Scala与Python的Monad应用差异

核心观点解读 #

Steven F. Lott的说法核心在于Monad的核心刚需场景是非严格（惰性）求值语言的顺序控制：

• 非严格求值语言（比如Haskell）默认不会按代码书写顺序执行表达式，I/O这类有副作用的操作完全依赖Monad（比如IO Monad）来强制先后顺序，否则read/write的执行顺序会混乱，甚至根本不执行。
• 而严格求值语言（比如Python、默认模式下的Scala）本身就会按代码逻辑顺序执行表达式，不需要Monad来兜底顺序。比如Scala里println("a"); println("b")必然先输出a再输出b，天然满足顺序要求。

那Scala里为什么还常用Monad？因为Monad除了控制顺序，还有简化嵌套控制流、统一错误/状态处理的附加价值——这是“锦上添花”，而非“必需”。严格语言本身的语法（if/else、try/catch、循环）已经能实现同样逻辑，只是Monad让代码更简洁、更符合函数式风格。

Scala示例：惰性场景必须用Monad，严格场景Monad可选 #

1. 惰性求值场景：必须依赖Monad控制顺序 #

Scala中的lazy val、Stream等是惰性求值的，此时如果有依赖顺序的副作用操作，普通写法无法保证顺序，必须用Monad约束。

我们先实现一个极简版的IO Monad（避免依赖外部库）：

// 极简版IO Monad，封装副作用操作
sealed trait IO[A] {
  def flatMap[B](f: A => IO[B]): IO[B] = FlatMap(this, f)
  def map[B](f: A => B): IO[B] = flatMap(a => Pure(f(a)))
  def run: A = this match {
    case Pure(value) => value
    case Suspend(thunk) => thunk()
    case FlatMap(io, f) => f(io.run).run
  }
}
case class Pure[A](value: A) extends IO[A]
case class Suspend[A](thunk: () => A) extends IO[A]
case class FlatMap[A, B](io: IO[A], f: A => IO[B]) extends IO[B]

// 封装常用IO操作
def readLine: IO[String] = Suspend(() => scala.io.StdIn.readLine())
def printLine(msg: String): IO[Unit] = Suspend(() => println(msg))

错误示例：惰性值导致顺序失控

// 惰性求值下，执行顺序完全取决于谁先被调用
lazy val input = scala.io.StdIn.readLine()
lazy val output = println(s"You entered: $input")

output // 执行时会先打印"You entered: "，然后才等待输入，完全不符合预期

正确示例：IO Monad强制顺序

// 通过for推导式（本质是flatMap链式调用）绑定执行顺序
val program: IO[Unit] = for {
  _ <- printLine("Enter something:")
  input <- readLine
  _ <- printLine(s"You entered: $input")
} yield ()

program.run // 执行顺序严格：打印提示 → 等待输入 → 输出结果，完全符合预期

在这个惰性场景下，没有Monad的话，我们无法可靠控制副作用操作的执行顺序，必须依赖Monad的链式调用机制来绑定流程。

2. 严格求值场景：Monad可选，仅为风格优化 #

在Scala默认的严格求值模式下，传统控制结构和Monad都能实现同样逻辑，Monad只是提供更简洁的函数式写法。

以错误传播场景为例，对比Either Monad和传统try/catch：

方式1：用Either Monad（函数式风格）

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

// 用flatMap链式传播错误
def processNumbers(x: Int, y: Int, z: Int): Either[String, Int] = {
  divide(x, y).flatMap(result1 => divide(result1, z))
}

// 用for推导式简化写法
def processNumbersFor(x: Int, y: Int, z: Int): Either[String, Int] = for {
  result1 <- divide(x, y)
  result2 <- divide(result1, z)
} yield result2

// 调用测试
processNumbersFor(10, 2, 5) // Right(1)
processNumbersFor(10, 0, 5) // Left("Division by zero")

方式2：用传统控制结构（无需Monad）

def processNumbersTraditional(x: Int, y: Int, z: Int): Either[String, Int] = {
  try {
    val result1 = x / y
    val result2 = result1 / z
    Right(result2)
  } catch {
    case _: ArithmeticException => Left("Division by zero")
  }
}

// 调用测试
processNumbersTraditional(10, 2, 5) // Right(1)
processNumbersTraditional(10, 0, 5) // Left("Division by zero")

在这个严格场景下，两种方式完全等价，Monad不是必需的——它只是把命令式的try/catch转换成了更符合函数式风格的无副作用写法，简化了嵌套逻辑。

内容的提问来源于stack exchange，提问作者Amaterasu