【问题标题】:Clojure's 'let' equivalent in ScalaClojure 在 Scala 中的“让”等价物
【发布时间】:2011-06-20 08:49:27
【问题描述】:

我经常遇到以下情况:假设我有这三个功能

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 function,我可以在一个表达式中定义这个函数。

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

1 - 使用 scalaz 我可以这样定义它(有没有更好的方法来使用 scalaz 做到这一点?):

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

我不喜欢这个解决方案的地方在于它是嵌套的。我拥有的vals 越多,这个嵌套就越深。

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 的做法看起来很优雅)?

另一方面,它连接到Referential transparency。所有三个函数都是引用透明的(在我的示例中firstFn 计算一些常数,如 Pi),因此理论上它们可以用计算结果替换。我知道这一点,但编译器不知道,所以它无法优化我的第一次尝试。这是我的第二个问题:

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

编辑

感谢大家的精彩回答!选择一个最佳答案是不可能的(可能是因为他们都很好)所以我会接受投票最多的答案,我认为这很公平。

【问题讨论】:

  • 好问题。我会说——尽管这取决于谁的定义;-)——Scala 中的“惯用”在大多数情况下是带有“显式卷曲”和嵌套的。我很难说 Scala 语法在函数式语言特性方面特别优雅。
  • 我想我不确定你的计算函数与 Clojure 的 let 有何不同/更差:(defn calculate [^long a] (let [first (first-fn) second (second-fn first)] (third-fn first second (+ second a))))
  • 您可以在 for 理解的末尾添加 get,但您所做的只是用大括号替换括号。另一方面,clojure 的 let 和 scala 的区别在于括号和括号与花括号。

标签: scala clojure scalaz let


【解决方案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 版本。

Identity monad 存在于更复杂的 Scalaz 中

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

【讨论】:

  • 值得注意的是,隐式转换到(和从)身份在这种情况下也有效,因此您不需要在Identity 中显式包装。
  • for 理解的格式似乎很糟糕。我会“修复”它,但如果事实证明这是您想要的方式,请提前接受我的借口。
  • @James:谢谢,我喜欢Identity 的解决方案。对我来说,看起来比 Option 更一致。
  • @Rex:我导入了import scalaz._; import Scalaz._ 并尝试了这个:for (f &lt;- firstFn; s &lt;- secondFn(f)) yield thirdFn(f, s, s + a),但编译器抱怨firstFn:值 flatMap 不是 Int 的成员
  • @Easy Angel - 您确实需要编写自己的隐式转换;我并不是要暗示转换会自动出现在 Scalaz 中。
【解决方案2】:

坚持原来的形式:

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

  thirdFn(first, second, second + a)
}

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

【讨论】:

  • 事实上,在 Scala 中。块是表达式,其值是其中最后一个子表达式的值。所以真的没有太大区别
【解决方案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))

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

【讨论】:

  • 您的第一个解决方案调用将如下所示:calculate(5)()()... 乍一看看起来很特别:) 我认为它更适合私有方法,因为用户实际上可以使用所有 3 个参数并中断我美丽的算法:)。我喜欢你的第二个想法......它实际上启发了类似的东西 - 有一些隐含的魔法和一些帮助类我可以写这样的东西:firstFn and secondFn in ((f, s) =&gt; thirdFn(f, s, s + a)).
【解决方案4】:

如果你觉得第一种形式更简洁/更优雅/更易读,那为什么不坚持下去呢?

首先,阅读来自 Martin Odersky 的 Scala 编译器的 this recent commit message 并将其牢记在心...


也许这里真正的问题是立即跳枪声称它是次优的。 JVM 非常擅长优化这类事情。有时,这简直太棒了!

假设您在真正需要加速的应用程序中遇到真正的性能问题,您应该从探查器报告开始证明这是一个重大的瓶颈,在适当的配置和预热启动 JVM。

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

【讨论】:

  • 如果函数可能有副作用,那么它甚至不等同于函数不重复的情况。我认为您大大低估了证明(即使对于 JVM)有 vars 的情况和没有的情况是相同的难度,除非代码已经基本上没有工作,在这种情况下您不太可能担心太慢了。
  • @rex - 绝对是 100%,但问题是关于优化的。没有任何迹象表明实际上已经观察到性能或副作用是这里的问题。
  • @Kevin: 伟大的提交信息 :) 你启发了我做我的“迷你基准”(我知道......这本身可以被认为是邪恶的来源:)。所以结果:我的第一种方法(未优化) - 84ms,优化版本 - 65ms,用于理解选项 - 233ms,带有|&gt; 的scalaz版本 - 311ms,and ...in 版本,我在回复中写道到 Rex Kerr - 160 毫秒,最后是 Rex Kerr 的第一个带有 3 个参数的解决方案 - 77 毫秒。
  • @Easy - 问题解决了。如果性能是您的主要关注点,那么要走的路是显而易见的!而且,任何种可能性似乎都不是特别难读懂...为基于证据的优化赢得另一场胜利!
  • 优化就像性高潮,被某些人过度追求,往往正是你需要的,过早的时候永远不会好。我在这里关心的不是优化的想法,只是明显的过早。
【解决方案5】:

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

def calculate(a: Long) = firstFn match { case f => secondFn(f) match { case s => thirdFn(f,s,s + a) } }

【讨论】:

    【解决方案6】:

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

    看起来有点奇怪,但相当简洁,没有重复调用:

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

    【讨论】:

      猜你喜欢
      • 2014-03-15
      • 2014-03-11
      • 2012-07-03
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2016-07-05
      • 2021-08-07
      • 1970-01-01
      相关资源
      最近更新 更多