Question

为什么要关注代码

def doSomething() = "Something"

var availableRetries: Int = 10

def process(): String = {
  while (true) {
    availableRetries -= 1
    try {
      return doSomething()
    } catch {
      case e: Exception => {
        if (availableRetries < 0) {
          throw e
        }
      }
    }
  }
}

产生以下编译器错误

error: type mismatch;
 found   : Unit
 required: String
             while (true) {
             ^

这在C＃中可行。 while循环永远，所以它不能终止，因此它不能产生除字符串以外的东西。或者如何在Scala中创建无限循环？

Answer 1

与基于语句的语言的C＃（以及Java和C和C ++）不同，Scala是一种基于表达式的语言。在可组合性和可读性方面，这主要是一个很大的优势，但在这种情况下，差异已经让你感到困扰。

Scala方法隐式返回方法

中最后一个表达式的值

scala> def id(x : String) = x
id: (x: String)String

scala> id("hello")           
res0: String = hello

在Scala中，几乎所有东西都是表达式。看起来像语句的东西仍然是表达式，它返回一个名为Unit的类型的值。该值可以写为（）。

scala> def foo() = while(false){}
foo: ()Unit

scala> if (foo() == ()) "yes!" else "no"
res2: java.lang.String = yes!

没有用于图灵等效语言的编译器可以检测到所有非终止循环（例如，图灵暂停问题），因此大多数编译器只能做很少的工作来检测任何。在这种情况下，“while（someCondition）{...}”的类型是Unit，无论someCondition是什么，即使它是常数也是真的。

scala> def forever() = while(true){}
forever: ()Unit

Scala确定声明的返回类型（String）与实际返回类型（Unit）不兼容，后者是最后一个表达式的类型（while ...）

scala> def wtf() : String = while(true){}
<console>:5: error: type mismatch;
 found   : Unit
 required: String
       def wtf() : String = while(true){}

答案：最后添加例外

scala> def wtfOk() : String = {
     | while(true){}
     | error("seriously, wtf? how did I get here?")
     | }
wtfOk: ()String

Answer 2

定义无限循环的功能方法是递归：

@annotation.tailrec def process(availableRetries: Int): String = {
  try {
    return doSomething()
  } catch {
    case e: Exception => {
      if (availableRetries < 0) {
        throw e
      }
    }
  }
  return process(availableRetries - 1)
}

elbowich 的retry函数没有内部loop函数：

import scala.annotation.tailrec 
import scala.util.control.Exception._ 

@tailrec def retry[A](times: Int)(body: => A): Either[Throwable, A] = { 
  allCatch.either(body) match { 
    case Left(_) if times > 1 => retry(times - 1)(body) 
    case x => x 
  } 
}

Answer 3

遗憾的是，编译器不够聪明，无法知道你不能退出while循环。但是，即使您无法合理地生成返回类型的成员，也很容易欺骗 - 只是抛出异常。

def process(): String = {
  while (true) {
    ...
  }
  throw new Exception("How did I end up here?")
}

现在编译器会意识到即使它转义了while循环，它也不能在那里返回一个值，所以它不担心while循环有返回类型Unit（即不返回值）。

Answer 4

import scala.annotation.tailrec
import scala.util.control.Exception._

def retry[A](times: Int)(body: => A) = {
  @tailrec def loop(i: Int): Either[Throwable, A] =
    allCatch.either(body) match {
      case Left(_) if i > 1 => loop(i - 1)
      case x => x
    }
  loop(times)
}

retry(10) {
  shamelessExceptionThrower()
}

Answer 5

编辑：我刚刚注意到了实际的return语句。 while循环中的return语句将被忽略。例如，在REPL中：

scala> def go = while(true){return "hi"}
<console>:7: error: method go has return statement; needs result type
   def go = while(true){return "hi"}
                        ^

你告诉编译器process()方法返回String，但你的方法体只是一个while循环，它不会返回任何东西（它是{{1} }或Java Unit）。更改返回类型或在while循环后添加一个String。

void

或

def process(): Unit = {
   while(true){...}
}

Answer 6

基于我使用的senia，elbowich和dave解决方案：

@annotation.tailrec
def retry[T](availableRetries: Int)(action: => T): T = {
  try {
    return action
  } catch {
    case e: Exception if (availableRetries > 0) => { }
  }
  retry(availableRetries - 1)(action)
}

然后可以将其用作elbowich和dave的解决方案：

retry(3) {
  // some code
}

Scala虽然（真）类型不匹配？ scala中的无限循环？

6 个答案: