Scala while (true) несоответствие типа? Бесконечная петля в scala?

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

на основе senia, elbowich и dave «s решения я использовал следующее:

@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 и решений Дэйва:

retry(3) { 
    // some code 
} 

Answer 2

Редактировать: Я только что заметил фактический оператор возврата. Оператор return внутри цикла while будет проигнорирован. Например, в 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 петля, которая ничего не возвращает (это Unit, или Java void). Либо измените тип возврата, либо добавьте строку после цикла while.

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

или

def process(): String = { 
    while(true){...} 
    "done" 
} 

Answer 3

Компилятор не достаточно умен, чтобы знать, что вы не можете выйти из цикла WHILE, к сожалению. Однако легко обмануть, даже если вы не можете разумно генерировать член возвращаемого типа - просто выбросьте исключение.

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

Теперь компилятор будет понимать, что даже если он избегает время цикла, он не может возвращать значение там, так что не беспокойтесь о том, что цикл в то время как имеет тип Unit возврата (т.е. не возвращать стоимость).

Answer 4

В отличие от 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! 

Нет компилятор для Тьюринг-эквивалентного языка может обнаружить все не оконечные петли (c.f. Тьюринга проблемы остановки), так что большинство компиляторов делает очень мало работу для обнаружения любого. В этом случае тип «while (someCondition) {...}» - это единица, независимо от того, что такое someCondition, даже если это константа true.

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

Scala определяет, что заявленный тип возвращаемого (String) не совместим с фактическим типом возвращаемого (Unit), который является типом последнего выражения (в то время как ...)

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 5

Функциональный способ определения бесконечного цикла является рекурсия:

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

elbowich «s 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 6

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() 
}