재귀를 접기로 변환하는 방법

Question

기능적 프로그래머 인 Erik Meijer는 재귀 대신에 fold를 사용해야 함을 알고 있습니다. 어떻게 접어서 사용하도록 다음과 같이 변환합니까? 나는 돌아 오는 길 한 가지를 볼 수는 있지만, fp에서는 회귀도 피해야합니다. 감사!

def tryOld(string: String, original: Exception, zomOldList: List[String => Double]): Double = { 
    zomOldList match { 
    case Nil => 
     throw original 
    case head :: tail => 
     try { 
     head(string) 
     } catch { 
     case ex: Exception => 
      tryOld(string, original, tail) 
     } 
    } 
} 

Answer 1

다음은 foldLeft가있는 해결책입니다. tryOldString에 의해 호출 된 제네릭 함수를 처음 작성한 이후로 길다.

def tryOld[In, Error, Out](
    in: In, 
    original: Error, 
    zomOldList: List[In => Either[Error, Out]] 
): Either[Error, Out] = { 
    val seed: Either[Error, Out] = Left(original) 
    zomOldList.foldLeft(seed) { 
     case (prev, f) => 
     // stores first match without return 
     if (seed != prev) { 
      prev 
     } else { 
      f(in).fold(
      fa => 
       prev, 
      fb => 
       Right(fb) 
     ) 
     } 
    } 
    } 

    def tryOutString(string: String, original: Exception, zomOldList: List[String => Double]): Double = { 
    val zomFunctions: List[String => Either[Exception, Double]] = zomOldList.map { 
     f => 
     s: String => 
      try { 
      Right(f(s)) 
      } catch { 
      case e: Exception => 
       Left(e) 
      } 
    } 
    tryOld(string, original, zomFunctions).fold(
     bad => throw original, 
     good => good 
    ) 
    } 

Answer 2

접기로 구현할 수 없습니다. 컬렉션의 모든 요소에 대해 반복적으로 반복하는 반면 tryOld은 가끔 일찍 종료됩니다. 당신은 Stream의 게으름을 활용하고 collectFirst 및 Try의 관점에서 구현할 수 :

import scala.util.Try 

def tryOld(string: String, original: Exception, zomOldList: List[String => Double]): Double = 
    zomOldList.toStream.map(x => Try(x(string))) collectFirst { 
    case Success(x) => x 
    } getOrElse (throw original) 

를하지만, 원래 재귀 구현은 명확하고 더 성능이 좋은 것입니다.

편집 : 스칼라는 하스켈의 foldr 같은 게으름의 특성을 가진 foldRight이 있다면

, 다음이 foldRight의 관점에서 정의 할 수 있습니다 : 그러나

implicit class GiveStreamAWorkingFoldRight[A](val s: Stream[A]) extends AnyVal { 
    def lazyFoldRight[B](z: => B)(f: (A,() => B) => B): B = 
    if (s.isEmpty) z else f(s.head,() => s.tail.lazyFoldRight(z)(f)) 
} 

def tryOld(string: String, original: Exception, zomOldList: List[String => Double]): Double = 
    zomOldList.toStream.lazyFoldRight(throw original) { (a, b:() => Double) => 
    try { 
     a(string) 
    } catch { 
     case ex: Exception => b() 
    } 
    } 

, 진정한 꼬리의 스칼라의 부족 -call 최적화는 b을 호출 할 때마다 스택 오버플로를 유발할 수있는 새로운 스택 프레임을 도입한다는 것을 의미합니다.

Answer 3

당신은 foldRight 함수 값 인 활용과이를 구현할 수 있습니다

import util.control.NonFatal 
def tryOld(string: String, original: Exception, zomOldList: List[String ⇒ Double]): Double = { 
    val unhandled: String ⇒ Double = _ ⇒ throw original 
    zomOldList.foldRight(unhandled) { (f, z) ⇒ 
    x ⇒ try { f(x) } catch { case NonFatal(_) ⇒ z(x) } 
    }(string) 
} 

주 우리는 우리가 잡기해서는 안 예외를 잡기 피하기 위해 여기 NonFatal를 사용합니다. 예외를 직접 사용하지 않아보다 우아한 방법으로이 코드를 작성할 수 있습니다.