Scala 的 Try 是引用透明的吗？

Question

我目前正在做一个关于函数式编程的演示文稿，遇到了以下问题。

函数式编程旨在将 'what' 与 'how' 分开，或者更准确地说，将计算的声明与其解释分开。这就是为什么该范例的主要焦点之一是使用可组合数据结构来表示计算，而不对它们的执行方式做出任何假设。例如：

// Represents a computation that may fail
case class Unsafe[A,B](run: A => B)

// ...
val readIntFromFile: Unsafe[String, Int] = Unsafe { filePath => /* ... */ }
interpret(readIntFromFile)

// Interpreter
def interpret(u: Unsafe[String, Int]): Unit = {
  try {
    u.run("path/to/file")
  } catch {
    case e => /* ... */
  }
}

这似乎是有道理的，因为副作用应该只在计算执行期间执行，而不是在其声明期间执行。问题是在 Scala 中，许多数据结构似乎都违反了这条规则：

object Try {
  /** Constructs a `Try` using the by-name parameter.  This
   * method will ensure any non-fatal exception is caught and a
   * `Failure` object is returned.
   */
  def apply[T](r: => T): Try[T] =
    try Success(r) catch {
      case NonFatal(e) => Failure(e)
    }
}

Futures也一样：

  /** Starts an asynchronous computation and returns a `Future` object with the result of that computation.
  *
  *  The result becomes available once the asynchronous computation is completed.
  *
  *  @tparam T       the type of the result
  *  @param body     the asynchronous computation
  *  @param executor  the execution context on which the future is run
  *  @return         the `Future` holding the result of the computation
  */
  def apply[T](body: =>T)(implicit @deprecatedName('execctx) executor: ExecutionContext): Future[T] = impl.Future(body)

所以，我现在想知道，Try 和 Future 真的是引用透明的吗？如果不是，那么如何在不依赖 Success 和 Failure 的情况下处理错误情况？

Answer 1

Future 绝对不是 RT，因为这两个块不等价：

两个future并行执行：

val fa: Future[Int] = service.call
val fb: Future[Int] = service.call

for { a <- fa; b <- fb } yield a + b

两个期货依次执行：

for { a <- service.call; b <- service.call } yield a + b

另一方面，

Try 是。处理错误的正确功能方法是将 Either[ErrorDescription, A] 用于 returns 和 A 但可能会失败的方法（您可以使用 type ErrorDescription = Throwable 相当于 scala.util.Try!).

Answer 2

只要不使用副作用，Try 就是引用透明的。 Try 的目的不是为了控制副作用，而是为了处理可能出现的异常。

如果您需要以纯粹的方式控制副作用，您可以使用 Cats 和 Scalaz 等库中的 Task 或 IO 类型。

Scala 的 Try 是引用透明的吗？

Is Scala's Try referentially transparent?

functional-programming

scala

side-effects

referential-transparency