scala中的懶惰函數定義

Question

我一直在學習scala，我得說這是一種非常酷的語言。我特別喜歡它的模式匹配功能和函數文字，但是我來自javascript，ruby背景，並且在這些語言中我最喜歡的模式之一是懶惰函數和方法定義模式。在JavaScript的一個例子是

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

相同的代碼稍作調整工作在紅寶石，你只需要使用單獨的對象重新定義法進行計算後。當涉及昂貴的計算時，這種事情非常方便，而且如果您需要結果，您不會提前知道。我知道在scala中我可以使用緩存來模擬同樣的結果，但我試圖避免條件檢查，到目前爲止，我的實驗已經返回負面結果。有誰知道在scala中是否有懶惰的函數或方法定義模式？

注意：JavaScript代碼來自Peter Michaux的site。

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 

，該模式expensive: => String被稱爲由名稱參數，你能想到的是，「給我的東西，將產生上要求的字符串。」請注意，如果你使用它的兩倍，它在每次的時間，這就是蘭德爾·舒爾茨的方便模式來在重新生成：

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

斯卡拉有lazy val s，其初始值不被評估，除非和直到val被使用。惰性vals可以用作方法局部變量。

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

我認爲你的意思是「懶功能」是函數文字或匿名函數。

在斯卡拉你可以做這樣的事情，非常類似於你發佈的JavaScript代碼。

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

    foo() 
} 

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

的主要區別在於：

• 你不能重新分配外富
• 沒有「功能」關鍵字，而不是你使用類似（S：字符串）= > {code}
• 最後一條語句是塊的返回值，所以你不需要添加「return」。

Answer 4

您可以定義一個懶惰的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 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

我認爲一些響應者對你說的這個問題的方式有些困惑。斯卡拉構建你想在這裏是一個簡單的懶人定義：

lazy val foo = new java.util.Date 

Date對象的建設將至多出現一次被推遲，直到第一次引用FOO。