scala 中的惰性函数定义

Question

我一直在学习 Scala，我不得不说这是一门非常酷的语言。我特别喜欢它的模式匹配功能和函数文字，但我有 javascript、ruby 背景，这些语言中我最喜欢的模式之一是惰性函数和方法定义模式。 javascript 中的一个示例是

var foo = function() {
  var t = new Date();
  foo = function() {
    return t;
  };
  return foo();
};

在 ruby​​ 中使用相同的代码，进行一些细微的调整，您只需在执行计算后使用单例对象重新定义方法。当涉及昂贵的计算并且您不提前知道是否需要结果时，这种事情非常方便。我知道在 scala 中我可以使用缓存来模拟相同类型的结果，但我试图避免条件检查，到目前为止我的实验返回了负面结果。有谁知道scala中是否有惰性函数或方法定义模式？

注意：JavaScript 代码来自 Peter Michaux 的网站。

Answer 1

JavaScript 中所有复杂的代码似乎只是试图缓存日期的值。在 Scala 中，您可以简单地实现同样的事情：

lazy val foo = new Date

并且，如果甚至不想创建 val，而是想调用一个仅在需要时执行昂贵代码的函数，您可以

def maybeExpensive(doIt: Boolean, expensive: => String) {
  if (doIt) println(expensive)
}
maybeExpensive(false, (0 to 1000000).toString)  // (0 to 1000000).toString is never called!
maybeExpensive(true, (0 to 10).toString)        // It is called and used this time

在模式 处贵：=> String 被称为按名称参数，您可以将其视为“给我一些可以根据请求生成字符串的东西”。请注意，如果您使用它两次，它每次都会重新生成它，这就是 Randall Schultz 的便捷模式的用武之地：

def maybeExpensiveTwice(doIt: Boolean, expensive: => String) {
  lazy val e = expensive
  if (doIt) {
    println(e)
    println("Wow, that was " + e.length + " characters long!")
  }
}

现在，仅在需要时才生成（通过名称参数）和存储它并在您再次需要时重新使用它（通过惰性 val）。

因此，请以这种方式而不是 JavaScript 方式进行操作，即使您可以使 Scala 看起来很像 JavaScript。

Answer 2

Scala 有惰性 val，除非使用 val，否则不会评估其初始值设定项。惰性 val 可以用作方法局部变量。

Scala 还具有按名称命名的方法参数，其实际参数表达式被包装在 thunk 中，并且每次在方法体中引用形式参数时都会对 thunk 进行求值。

这些可以一起用来实现惰性求值语义，例如 Haskell 中的默认语义（至少在我对 Haskell 的非常有限的理解中）。

def meth(i: => Int): Something = {
  //        ^^^^^^ by-name parameter syntax
  lazy val ii = i
  // Rest of method uses ii, not i
}

在此方法中，用作实际参数的表达式将被计算零次（如果方法体的动态执行路径从不使用 ii）或一次（如果它使用 ii）代码> 一次或多次）。

Answer 3

您可以定义一个惰性 val，它是一个函数：

lazy val foo = {
  val d = new Date
  () => { d }
}

println(foo())

foo() 现在每次都会返回相同的 Date 对象，该对象将在第一次调用 foo 时初始化。

为了稍微解释一下代码，第一次调用 foo() { val d = new Date; ()=> { d } } 被执行，d 被分配给一个新的日期值，然后它计算最后一个表达式 () =>; { d } 并将其分配给 foo 值。那么 foo 是一个没有参数的函数，返回 d。

Answer 4

我认为一些答复者对您提出问题的方式感到有点困惑。这里您想要的 Scala 构造是一个简单的惰性定义：

lazy val foo = new java.util.Date

Date 对象的构造最多发生一次，并推迟到第一次引用 foo 为止。

Answer 5

我对 Ruby 一无所知，但 scala 也有单例对象模式：

Welcome to Scala version 2.8.0.r22634-b20100728020027 (Java HotSpot(TM) Client VM, Java 1.6.0_20).
Type in expressions to have them evaluated.
Type :help for more information.

scala> object LazyInit {                                       
     |     val msec = { println("Hi,I'm here!");   System.currentTimeMillis }
     | }
defined module LazyInit

scala> System.currentTimeMillis                                              
res0: Long = 1282728315918

scala> println(System.currentTimeMillis +" : " + LazyInit.msec)              
Hi,I'm here!
1282728319929 : 1282728319930

scala> println(System.currentTimeMillis +" : " + LazyInit.msec)
1282728322936 : 1282728319930

scala> println(System.currentTimeMillis +" : " + LazyInit.msec)
1282728324490 : 1282728319930

scala> 

如果你想获取函数，你可以将其设为函数类型的子类型：

scala> object LazyFun extends (() => Long) {            
     |     val msec = System.currentTimeMillis          
     |     def apply() = msec                           
     | }
defined module LazyFun

scala> System.currentTimeMillis                         
res2: Long = 1282729169918

scala> println(System.currentTimeMillis + " : " + LazyFun())
1282729190384 : 1282729190384

scala> println(System.currentTimeMillis + " : " + LazyFun())
1282729192972 : 1282729190384

scala> println(System.currentTimeMillis + " : " + LazyFun())
1282729195346 : 1282729190384

Answer 6

我认为你的意思是“惰性函数”是函数文字或匿名函数。

在 Scala 中，您可以执行类似的操作，与您发布的 javascript 代码非常相似。

val foo = () => {
    val t = new Date()
    val foo = () => {t}

    foo()
}

println ("Hello World:" + foo())

主要区别在于：

• 您无法重新分配外部 foo
• 没有“function”关键字，而是使用类似 (s:String) => 的内容。 {code}
• 最后一条语句是块的返回值，因此不需要添加“return”。