Rozwiązanie Idiomatic Scala do imperatywnego kodu

Question

Jakie są pomysły na wyrażanie tej funkcji w Scence "idiomatycznej". A dokładniej, czy istnieje sposób na usunięcie lokalnych więzów bez utraty czytelności?

def solve(threshold: Int)(f: Int => Int): Int = { 
    var sum = 0 
    var curr = 0 
    while(sum < threshold) { 
    sum += f(curr) 
    curr += 1 
    } 
    curr 
} 

Jedyne, co mogłem wymyślić, to, ale jest dłuższa i mniej czytelna według mnie.

def solve2(threshold: Int)(f: Int => Int): Int = { 
    val resultIterator = Iterator.iterate (0, 0) { case (curr, sum) => 
    (curr + 1, sum + f(curr)) 
    } 
    (resultIterator find (_._2 >= threshold)).get._1 
} 

Answer 1

Najbardziej bezpośrednim podejściem jest przekształcenie pętli while w zagnieżdżoną funkcję rekurencyjną.

def solve(threshold: Int)(f: Int => Int): Int = { 
    def solveLoop(sum: Int, curr: Int): Int = if (sum < threshold) { 
     solveLoop(sum + f(curr), curr + 1) 
    } else { 
     curr 
    } 
    solveLoop(0,0) 
} 

Jest to standardowy "funkcjonalny" sposób zapętlania.

Answer 2

def solve(threshold: Int)(f: Int => Int): Int = { 
    Iterator.from(0).map(f).scanLeft(0)(_ + _).indexWhere(threshold <=) 
} 

Moim zdaniem wersja z pętlą jest znacznie bardziej przejrzysta.

Answer 3

mógł

def solve(threshold: Int, i: Int = 0)(f: Int => Int) = { 
    if (threshold <= 0) i else solve(threshold - f(i), i+1)(f) 
} 

ale nie jestem pewien, że to faktycznie jaśniej Ty. Należy pamiętać, że jest to rzeczywiście więcej znaków niż kompaktowej wersji pętli while:

def solve(threshold: Int)(f: Int => Int) = { 
    var s,i = 0; while (s < threshold) { s += f(i); i += 1 }; i 
} 

Pętle z modyfikowalnych zmiennych nie zawsze są złe, „idiomatyczne” lub nie. Po prostu zachowaj bezpieczny stan zawarty w tej funkcji, a każdy, kto widzi, jest funkcją bezpaństwową.

Nawiasem mówiąc, chociaż sum jest rozsądną nazwą zmiennej, to wątpliwe jest, czy jest to curr. Co jest nie tak z i? Jest szeroko stosowany jako zmienna indeksowa, a zresztą posiadanie zmiennej w ogóle jest uciążliwe; chodzi o to, że bierzesz coś i zwiększasz, cokolwiek to jest, krok po kroku za każdym razem, a potem zwracasz. To właśnie ten przepływ logiki, a nie nazwa, mówi wam (i innym), do czego to służy.

Answer 4

Zawsze się zastanawiam, kiedy ludzie mówią o "idiomatycznej" scali. Ponieważ moim zdaniem każdy ma własną percepcję idiomatyczną. Jeśli szukasz funkcjonalnego rozwiązania, chciałbym zaproponować ci spojrzenie na "istotę wzoru iteratora". Tu jest rzeczywiście bardzo dobry blogpost w Scala na ten temat to sprawdzić tutaj: http://etorreborre.blogspot.com/2011/06/essence-of-iterator-pattern.html

Answer 5

Oto w jaki sposób mogę to zrobić w Haskell:

solve threshold f = snd $ until test step (0, 0) 
    where test (sum, i) = sum >= threshold 
     step (sum, i) = (sum + f i, succ i) 

To wyraźnie zaznacza test The step, a początkowy wartości, podobnie jak wersja imperatywna. Nie jestem pewien, czy Scala ma until w libs gdzieś, ale to jest trywialne, aby zdefiniować:

def until[A](test: A => Boolean)(f: A => A)(v: A): A = { 
    if (test(v)) { 
    v 
    } else { 
    until(test)(f)(f(v)) 
    } 
} 

def solve(threshold: Int)(f: Int => Int): Int = { 
    def test = (sum: Int, i: Int) => sum >= threshold 
    def step = (sum: Int, i: Int) => (sum + f(i), i + 1) 
    until(test.tupled)(step.tupled)((0, 0))._2 
}