如何使 Scala 控制重复直到抽象？

Question

我是彼得·皮尔格林。我看到 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 ) }
  }

}

错误消息如下：

信息：编译已完成，有 1 个错误和 0 个警告
信息：1 个错误
信息：0 条警告
C:\Users\Peter\IdeaProjects\HelloWord\src\demo\Control.scala
错误：错误：第 (57) 行错误：Control.this.repeatLoop({
scala.this.Predef.println("找到 y=".+(y));
y = y.+(1)
Control.this.Until 类型的 }) 不带参数
重复循环 {

函数体可以被认为是返回一个表达式（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 的说法，这是一个没有异常的解决方案。

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

错误意味着 Scala 认为你正在尝试调用带有类似签名的方法：

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（尝试 < code>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 优化。

爱斯卡拉:)