Scala podczas niezgodności typu (true)? Nieskończona pętla w scala?

Question

Dlaczego następujący kod

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

produkuje następujący błąd kompilatora

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

?

Działa to dobrze w języku C#. Pętla while pozostaje na zawsze, więc nie może zakończyć, dlatego nie może spowodować czegoś innego niż string. Lub jak zrobić nieskończoną pętlę w Scali?

Answer 1

podstawie senia, elbowich i dave „s rozwiązań użyłem następujących:

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

które następnie mogą być wykorzystane jako elbowich i rozwiązań Dave'a:

retry(3) { 
    // some code 
} 

Answer 2

edytuj: Właśnie zauważyłem faktyczny zwrot. Instrukcja return wewnątrz pętli while zostanie zignorowana. Na przykład, w 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"} 
         ^ 

---

Mówiłeś kompilator, że metoda process() zwraca String, ale twoje ciało metoda jest tylko while pętla, która nie zwraca niczego (to Unit, lub Java void). Zmień typ zwracanego tekstu lub dodaj ciąg po pętli while.

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

lub

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

Answer 3

Kompilator nie jest wystarczająco inteligentny, aby wiedzieć, że nie można wyjść z pętli while, niestety. Łatwo jest jednak oszukać, nawet jeśli nie można rozsądnie wygenerować elementu zwracającego - wystarczy rzucić wyjątek.

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

Teraz kompilator będzie sobie sprawę, że nawet w przypadku jego ucieczki pętli while, że nie może wrócić tam wartość, więc nie martw się, że pętla ma natomiast typ Unit powrotu (czyli nie zwraca wartość).

Answer 4

W przeciwieństwie do języków C# (oraz Java i C i C++), które są językami opartymi na instrukcjach, Scala jest językiem opartym na ekspresji. To głównie duży plus pod względem kompozycyjności i czytelności, ale w tym przypadku różnica cię ugodziła.

metoda A Scala niejawnie zwraca wartość ostatniego wyrażenia w metodzie

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

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

w Scala prawie wszystko jest wyrażeniem. Rzeczy, które wyglądają jak instrukcje, są nadal wyrażeniami, które zwracają wartość typu o nazwie Jednostka. Wartość można zapisać jako().

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

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

Nie kompilator dla Turing-równoważnej języku można wykryć wszystkie non-zakończenia pętli (por Turing zatrzymanie problem) więc większość kompilatorów zrobić bardzo mało pracy, aby wykryć każdy. W tym przypadku typ "while (someCondition) {...}" jest jednostką bez względu na to, co jest pewne, nawet jeśli jest to stała prawda.

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

Scala stwierdzi, że zadeklarowany typ zwracany (String) nie jest zgodna z rzeczywistą typ zwracany (część), która jest rodzajem ostatniego wyrazu (gdy ...)

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

odpowiedzi: dodanie wyjątek na końcu

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

Answer 5

sposób funkcjonalny do wyznaczenia pętli nieskończonej jest rekursji:

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

elbowich jest retry funkcji bez wewnętrzna loop funkcja:

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