一個人如何讓Scala控制抽象重複直到？

Question

我是Peter Pilgrim。我看到Martin Odersky在Scala中創建了一個控制抽象。不過，我似乎還不能在IntelliJ IDEA 9中重複它。它是IDE嗎？

package demo 

class Control { 

    def repeatLoop (body: => Unit) = new Until(body) 

    class Until(body: => Unit) { 
    def until(cond: => Boolean) { 
     body; 
     val value: Boolean = cond; 
     println("value="+value) 
     if (value) repeatLoop(body).until(cond) 
     // if (cond) until(cond) 
    } 
    } 

    def doTest2(): Unit = { 
    var y: Int = 1 
    println("testing ... repeatUntil() control structure") 
    repeatLoop { 
     println("found y="+y) 
     y = y + 1 
    } 
    { until (y < 10) } 
    } 

} 

錯誤消息讀取：

Information:Compilation completed with 1 error and 0 warnings
Information:1 error
Information:0 warnings
C:\Users\Peter\IdeaProjects\HelloWord\src\demo\Control.scala
Error:Error:line (57)error: Control.this.repeatLoop({
scala.this.Predef.println("found y=".+(y));
y = y.+(1)
}) of type Control.this.Until does not take parameters
repeatLoop {

在咖喱函數主體可以被認爲以返回一個表達式（y的值+ 1）然而repeatUntil的聲明機體參數明確地說，這可以忽略不計？

錯誤是什麼意思？

Answer 1

這是一個沒有StackOverflowError的解決方案。

scala> class ConditionIsTrueException extends RuntimeException 
defined class ConditionIsTrueException 

scala> def repeat(body: => Unit) = new { 
|  def until(condition: => Boolean) = { 
|  try { 
|   while(true) { 
|   body 
|   if (condition) throw new ConditionIsTrueException 
|   } 
|  } catch { 
|   case e: ConditionIsTrueException => 
|  } 
|  
|  } 
| } 
repeat: (body: => Unit)java.lang.Object{def until(condition: => Boolean): Unit} 

scala> var i = 0    
i: Int = 0 

scala> repeat { println(i); i += 1 } until(i == 3) 
0 
1 
2 

scala> repeat { i += 1 } until(i == 100000)  

scala> repeat { i += 1 } until(i == 1000000) 

scala> repeat { i += 1 } until(i == 10000000) 

scala> repeat { i += 1 } until(i == 100000000) 

scala> 

根據Jesper和Rex Kerr的說法，這裏是一個沒有Exception的解決方案。

def repeat(body: => Unit) = new { 
    def until(condition: => Boolean) = { 
    do { 
     body 
    } while (!condition) 
    } 
} 

Answer 2

你不需要第二對大括號，用法應該是：

repeatLoop (x) until (cond) //or... 
repeatLoop {x} until {cond} 

而不是：

repeatLoop {x} { until(cond) } //EXTRA PAIR OF BRACES 

的錯誤意味着是斯卡拉認爲你試圖調用一種簽名方法如下：

def repeatLoop(x: => Unit)(something: X) //2 parameter lists 

而且可以找到否這樣的方法。這是說「repeatLoop（body）」不帶參數。一個完整的代碼解決方案上市可能看起來有點更像是：

object Control0 { 
    def repeatLoop(body: => Unit) = new Until(body) 

    class Until(body: => Unit) { 
    def until(cond: => Boolean) { 
     body; 
     val value: Boolean = cond; 

     if (value) repeatLoop(body).until(cond) 
    } 
    } 


    def main(args: Array[String]) { 
    var y: Int = 1 
    println("testing ... repeatUntil() control structure") 
    repeatLoop { 
     println("found y=" + y) 
     y += 1 
    }.until(y < 10) 
    } 
} 

有兩個有用的意見，使這裏：

1. 的解決方案是不是尾遞歸，並會導致StackOverflowError對於長時間的迭代（嘗試while (y < 10000)）
2. until似乎是對我來說錯誤的方式（當條件成立時停止會更自然，而不是繼續，而不是繼續）。

Answer 3

怎麼樣一個襯裏重複，直到。

def repeat(b: => Unit) = new AnyRef {def until(c: => Boolean) {b; while (! c) b}} 

其中，例如，給出了： -

scala> repeat { 
    | println("i = "+i) 
    | i+=1 
    | } until (i >= 10) 
i = 0 
i = 1 
i = 2 
i = 3 
i = 4 
i = 5 
i = 6 
i = 7 
i = 8 
i = 9 

Answer 4

如上又遞歸:)

def repeat(b: => Unit) = new {def until(c: => Boolean) = { b; if (c) until(c) }} 

var i = 0 
repeat { 
    println(i) 
    i+=1 
} until (i < 10) 

它@tailrec優化過。

Llove scala :)