为什么Scala的Future被认为不具备引用透明性？相关疑问解析

针对你提出的几个问题，结合《Scala with Cats》里的示例，逐一拆解：

1. Future的特殊之处：立即执行副作用，破坏引用透明性 #

Scala的Future之所以不符合纯函数式要求，核心原因是创建Future(expr)时，expr会立即在后台线程执行，而非延迟到你主动触发计算。这直接导致了引用透明性的破坏：

看你贴的示例：

• future1中，val x = Future(r.nextInt)创建时，r.nextInt已经执行了一次（修改了Random的内部状态），后续两次<- x只是复用同一个Future的已计算结果，所以得到相同数值；
• future2中，每次Future(r.nextInt)都会重新执行r.nextInt，每次都改变Random的状态，因此得到不同数值。

引用透明性要求相同表达式在任何上下文替换后结果一致，但把future1里的x替换成它的定义Future(r.nextInt)，得到的future2结果完全不同——这就是Future违反引用透明性的直接证明。

2. Identity函数/Monad是纯的，问题出在r.nextInt本身 #

identity函数（def identity[A](a: A): A = a）和Identity Monad（比如Cats的Id）完全具备引用透明性。你观察到的identity(r.nextInt)两次结果不同，责任不在identity，而在r.nextInt这个参数：

r.nextInt是带有副作用的表达式（每次调用都会修改Random的内部状态），它本身就不具备引用透明性——无论用不用identity包裹，多次调用它的结果都可能不同。如果给identity传入纯表达式（比如identity(42)），无论调用多少次结果都一致，完全符合引用透明性要求。

3. 并非大部分Monad都无引用透明性，纯函数式Monad严格遵守 #

纯函数式的Monad（比如Cats的IO、Task，Scala标准库的LazyList）是严格满足引用透明性的。它们的核心设计是描述计算逻辑，而非立即执行，只有当你主动触发（比如IO.unsafeRunSync）时，计算才会执行。

用CatsIO改写你的示例对比：

import cats.effect.IO
import scala.util.Random

// 对应future1：复用同一个IO的结果（需要memoize缓存）
val io1 = {
  val r = new Random(0L)
  val x = IO(r.nextInt).memoize
  for {
    a <- x
    b <- x
  } yield (a, b)
}

// 对应future2：每次都执行新的IO
val io2 = {
  val r = new Random(0L)
  for {
    a <- IO(r.nextInt)
    b <- IO(r.nextInt)
  } yield (a, b)
}

// 执行后，io1的结果和future1一致，io2和future2一致
// 关键是：如果把io1里的x替换成IO(r.nextInt).memoize，结果完全不变——这就是引用透明性的体现

而你提到的“传入纯表达式时Future结果一致”，是因为纯表达式本身没有副作用，即使立即执行多次，结果也相同。但这只是特例，Future的本质还是会立即执行表达式，一旦表达式有副作用，就会破坏引用透明性。

总结 #

• Future的特殊问题在于副作用的立即执行，这是它不符合引用透明性的核心原因；
• 非纯表达式（如r.nextInt）本身不具备引用透明性，与identity或Identity Monad无关；
• 绝大多数纯函数式Monad都遵守引用透明性，通过延迟执行、描述计算的方式避免副作用的不可控触发。

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