Clojure 的“让” Scala 中的等效项

Question

我经常面临以下情况：假设我有这三个函数

def firstFn: Int = ...
def secondFn(b: Int): Long = ...
def thirdFn(x: Int, y: Long, z: Long): Long = ...

，并且我还有 calculate 函数。我的第一个方法看起来像这样：

def calculate(a: Long) = thirdFn(firstFn, secondFn(firstFn), secondFn(firstFn) + a)

它看起来很漂亮并且没有任何花括号 - 只有一个表达式。但这不是最佳的，所以我最终得到了这段代码：

def calculate(a: Long) = {
  val first = firstFn
  val second = secondFn(first)
  
  thirdFn(first, second, second + a)
}

现在它是几个用大括号括起来的表达式。在这种时候我有点羡慕Clojure。使用 let 函数 我可以在一个表达式中定义此函数。

所以我的目标是用一个表达式定义计算函数。我想出了两个解决方案。

1 - 使用 scalaz 我可以这样定义它（有更好的方法使用 scalaz 来做到这一点吗？）：

  def calculate(a: Long) = 
    firstFn |> {first => secondFn(first) |> {second => thirdFn(first, second, second + a)}}

我不喜欢这个解决方案的是它是嵌套的。我的 val 越多，嵌套就越深。

2 - 通过 for 理解，我可以实现类似的目标：

  def calculate(a: Long) = 
    for (first <- Option(firstFn); second <- Option(secondFn(first))) yield thirdFn(first, second, second + a)

一方面，这个解决方案具有扁平结构，就像 Clojure 中的 let 一样，但另一方面，我需要包装函数' 产生 Option 并接收 Option 作为 calculate 的结果（我正在处理空值，这很好，但我不..并不想）。

有更好的方法来实现我的目标吗？处理这种情况的惯用方法是什么（也许我应该继续使用 vals...但是 let 的做法看起来很优雅）？

另一方面，它与引用透明度相关。所有三个函数都是引用透明的（在我的示例中，firstFn 计算一些常数，如 Pi），因此理论上它们可以用计算结果替换。我知道这一点，但编译器不知道，所以它无法优化我的第一次尝试。这是我的第二个问题：

我能否以某种方式（可能带有注释）向编译器提示，我的函数是引用透明的，以便它可以为我优化这个函数（例如，在那里放置某种缓存） )?

编辑

感谢大家的精彩回答！不可能选择一个最佳答案（可能是因为它们都很好），所以我会接受最多赞成票的答案，我认为这足够公平。

Answer 1

在非递归情况下，let 是 lambda 的重组。

def firstFn : Int = 42
def secondFn(b : Int) : Long = 42
def thirdFn(x : Int, y : Long, z : Long) : Long = x + y + z

def let[A, B](x : A)(f : A => B) : B = f(x)

def calculate(a: Long) = let(firstFn){first => let(secondFn(first)){second => thirdFn(first, second, second + a)}}

当然，这仍然是嵌套的。无法避免这一点。但你说你喜欢单子形式。这是恒等单子

case class Identity[A](x : A) {
   def map[B](f : A => B) = Identity(f(x))
   def flatMap[B](f : A => Identity[B]) = f(x)
}

这是你的单子计算。通过调用 .x 解开结果

def calculateMonad(a : Long) = for {
   first <- Identity(firstFn)
   second <- Identity(secondFn(first))
} yield thirdFn(first, second, second + a)

，但此时它看起来确实像原始的 val 版本。

Scalaz 中的 Identity monad 更加复杂

http://scalaz.googlecode .com/svn/continuous/latest/browse.sxr/scalaz/Identity.scala.html

Answer 2

坚持原始形式：

def calculate(a: Long) = {
  val first = firstFn
  val second = secondFn(first)

  thirdFn(first, second, second + a)
}

即使对于 Java 开发人员来说，它也简洁明了。它大致相当于 let，只是不限制名称的范围。

Answer 3

这是您可能忽略的一个选项。

def calculate(a: Long)(i: Int = firstFn)(j: Long = secondFn(i)) = thirdFn(i,j,j+a)

如果您确实想创建一个方法，我就会这样做。

或者，您可以创建一个避免嵌套的方法（可以将其命名为 let）：

class Usable[A](a: A) {
  def use[B](f: A=>B) = f(a)
  def reuse[B,C](f: A=>B)(g: (A,B)=>C) = g(a,f(a))
  // Could add more
}
implicit def use_anything[A](a: A) = new Usable(a)

def calculate(a: Long) =
  firstFn.reuse(secondFn)((first, second) => thirdFn(first,second,second+a))

但现在您可能需要多次命名相同的内容。

Answer 4

如果您觉得第一种形式更干净/更优雅/更具可读性，那么为什么不坚持使用它呢？

首先，阅读 Martin Odersky 向 Scala 编译器发送的这条最新提交消息并牢记在心......

---

也许这里真正的问题是立即声称它不是最佳的。 JVM 非常擅长优化这类事情。有时，这简直太神奇了！

假设您的应用程序确实存在性能问题，并且确实需要加速，那么您应该从分析器报告开始，证明，在经过适当配置和预热的 JVM 上，这是一个严重的瓶颈。

然后，也只有到那时，您才应该寻找使其更快的方法，但最终可能会牺牲代码的清晰度。

Answer 5

为什么不在这里使用模式匹配：

defcalculate(a:Long)=firstFnmatch{casef=> SecondFn(f) 匹配 { case s =>第三个Fn(f,s,s + a) } }

Answer 6

如何使用柯里化来记录函数返回值（前面参数组中的参数在后续组中可用）。

看起来有点奇怪但相当简洁并且没有重复调用：

def calculate(a: Long)(f: Int = firstFn)(s: Long = secondFn(f)) = thirdFn(f, s, s + a)

println(calculate(1L)()())