명령형 break 문 및 기타 루프 검사와 동등한 기능은 무엇입니까?

아래 논리가 있다고 가정 해 봅시다. 함수형 프로그래밍으로 작성하는 방법?

    public int doSomeCalc(int[] array)
    {
        int answer = 0;
        if(array!=null)
        {
            for(int e: array)
            {
                answer += e;
                if(answer == 10) break;
                if(answer == 150) answer += 100;
            }
        }
        return answer;
    }

대부분의 블로그, 기사의 예 ... 그냥 간단한 수학 함수 'Sum'의 간단한 경우를 설명합니다. 그러나 위와 비슷한 논리를 Java로 작성했으며 Clojure의 기능 코드로 마이그레이션하려고합니다. FP에서 위의 작업을 수행 할 수없는 경우 FP에 대한 프로모션 종류에이를 명시 적으로 명시하지 않습니다.

위의 코드는 완전히 필수적이라는 것을 알고 있습니다. 앞으로는 FP로 옮길 것을 미리 계획하지 않았습니다.

대부분의 기능적 언어에서 배열을 반복하는 것과 가장 가까운 것은 fold함수, 즉 배열의 각 값에 대해 사용자 지정 함수를 호출하고 누적 된 값을 체인을 따라 전달하는 함수입니다. 많은 기능적 언어에서 fold일부 조건이 발생하면 조기에 중지 할 수있는 옵션을 포함하여 추가 기능을 제공하는 다양한 추가 기능으로 보완됩니다. 게으른 언어 (예 : Haskell)에서 목록을 따라 더 이상 평가하지 않으면 간단히 중지 할 수있어 추가 값이 생성되지 않습니다. 따라서 예를 Haskell로 번역하면 다음과 같이 작성합니다.

doSomeCalc :: [Int] -> Int
doSomeCalc values = foldr1 combine values
  where combine v1 v2 | v1 == 10  = v1
                      | v1 == 150 = v1 + 100 + v2
                      | otherwise = v1 + v2

Haskell의 구문에 익숙하지 않은 경우이 줄을 세분화하면 다음과 같이 작동합니다.

doSomeCalc :: [Int] -> Int

int 목록을 허용하고 단일 int를 반환하여 함수의 유형을 정의합니다.

doSomeCalc values = foldr1 combine values

함수의 본문 : given argument values, foldr1arguments combine(아래 정의)와 함께 호출 된 return values. foldr1스크롤 프리미티브의 변형은 그리스트의 첫번째 값 어큐뮬레이터 세트로 시작한다 (따라서 1함수 이름), 그것은 보통이라고 왼쪽에서 오른쪽 기능 지정된 사용자 (사용 결합 오른쪽 배 , 따라서 r함수 이름에서). 그래서 foldr1 f [1,2,3]동등 f 1 (f 2 3)(또는 그 f(1,f(2,3))이상의 종래의 C 형 구문).

  where combine v1 v2 | v1 == 10  = v1

정의하는 combine지역 기능 : 두 개의 인수를 수신 v1하고 v2. 때 v110이다, 그냥 돌려줍니다 v1. 이 경우 v2는 평가되지 않으므로 루프가 여기서 중지됩니다.

                      | v1 == 150 = v1 + 100 + v2

또는 v1이 150이면 100을 추가하고 v2를 추가합니다.

                      | otherwise = v1 + v2

그리고 이러한 조건 중 어느 것도 맞지 않으면 v1을 v2에 추가하기 만하면됩니다.

결합 함수가 두 번째 인수를 평가하지 않으면 오른쪽 접힘이 종료된다는 사실은 Haskell의 게으른 평가 전략으로 인해 발생하기 때문에이 솔루션은 Haskell에 다소 고유합니다. Clojure를 모르지만 엄격한 평가를 사용한다고 생각하므로 fold표준 라이브러리에 조기 종료에 대한 특정 지원을 포함 하는 기능 이있을 것으로 기대합니다 . 이것은 종종 호출 foldWhile, foldUntil또는 유사한.

Clojure 라이브러리 문서를 간략히 살펴보면 이름 지정에서 대부분의 기능적 언어와 약간 다르며 fold원하는 것이 아닙니다 (병렬 계산을 가능하게하는 고급 메커니즘 임)이지만 reduce더 직접적입니다 동등한. reduced결합 함수 내 에서 함수를 호출 하면 조기 종료가 발생 합니다. 구문을 이해한다고 100 % 확신 할 수 없지만 찾고있는 것이 다음과 같은 것 같습니다.

(reduce 
    (fn [v1 v2]
        (if (= v1 10) 
             (reduced v1)
             (+ v1 v2 (if (= v1 150) 100 0))))
    array)

주의 : Haskell과 Clojure의 번역은이 특정 코드에 적합하지 않습니다. 그러나 그것들은 그것의 일반적인 요지를 전달합니다-이 예제들에 대한 특정한 문제들에 대해서는 아래 주석에서 논의를보십시오.

쉽게 재귀로 변환 할 수 있습니다. 그리고 꼬리 최적화 재귀 호출이 좋습니다.

의사 코드 :

public int doSomeCalc(int[] array)
{
    return doSomeCalcInner(array, 0);
}

public int doSomeCalcInner(int[] array, int answer)
{
    if (array is empty) return answer;

    // not sure how to efficiently implement head/tails array split in clojure
    var head = array[0] // first element of array
    var tail = array[1..] // remainder of array

    answer += head;
    if (answer == 10) return answer;
    if (answer == 150) answer += 100;

    return doSomeCalcInner(tail, answer);
}

나는 Jules의 답변을 정말로 좋아 하지만, 사람들이 게으른 함수형 프로그래밍에서 종종 놓친 부분을 지적하고 싶었습니다. 즉, 모든 것이 "루프 내부"일 필요는 없습니다. 예를 들면 다음과 같습니다.

baseSums = scanl (+) 0

offsets = scanl (\offset sum -> if sum == 150 then offset + 100 else offset) 0

zipWithOffsets xs = zipWith (+) xs (offsets xs)

stopAt10 xs = if 10 `elem` xs then 10 else last xs

result = stopAt10 . zipWithOffsets . baseSums

result [1..]         -- 10
result [11..1000000] -- 500000499945

로직의 각 부분을 별도의 함수로 계산 한 다음 함께 구성 할 수 있습니다. 이것은 일반적으로 문제 해결이 훨씬 쉬운 작은 기능을 허용합니다. 장난감 예제의 경우 아마도 이것이 제거하는 것보다 더 복잡해 지지만 실제 코드에서는 분리 된 함수가 종종 전체보다 훨씬 간단합니다.

대부분의 목록 처리 예제는 같은 사용 기능을 볼 수 map, filter, sum등 전체 목록에서 작동하는합니다. 그러나 귀하의 경우 조건부 조기 종료가 있습니다-일반적인 목록 작업에서 지원하지 않는 다소 드문 패턴입니다. 따라서 추상화 수준을 낮추고 재귀를 사용해야합니다. 이는 명령형 예제의 모양과 비슷합니다.

이것은 Clojure 로의 다소 직접적 (관용적이지 않은) 번역입니다.

(defn doSomeCalc 
  ([lst] (doSomeCalc lst 0))
  ([lst sum]
    (if (empty? lst) sum
        (if (= sum 10) sum
            (let [sum (+ sum (first lst))]
                 [sum (if (= sum 150) (+ sum 100) sum)]
               (recur (rest lst) sum))))))) 

편집 : 그 밖으로 쥘 포인트 reduceClojure의의는 어떻게 조기 종료를 지원합니다. 이것을 사용하는 것이 더 우아합니다.

(defn doSomeCalc [lst]  
  (reduce (fn [sum val]
    (if (= sum 10) (reduced sum)
        (let [sum (+ sum val)]
             [sum (if (= sum 150) (+ sum 100) sum)]
           sum))
   lst)))

어쨌든 명령형 언어에서와 같이 기능적 언어로 무엇이든 할 수 있지만 우아한 솔루션을 찾기 위해 사고 방식을 변경 해야하는 경우가 종종 있습니다. 명령형 코딩에서는 목록을 단계별로 처리하는 것을 생각하지만 기능적 언어에서는 목록의 모든 요소에 적용 할 연산을 찾습니다.

다른 답변에서 지적했듯이 Clojure는 reduced축소를 조기에 중지해야합니다.

(defn some-calc [coll]
  (reduce (fn [answer e]
            (let [answer (+ answer e)]
               (case answer
                 10  (reduced answer)
                 150 (+ answer 100)
                 answer)))
          0 coll))

특정 상황에 가장 적합한 솔루션입니다. 또한 결합에서 마일리지를 많이 얻을 수 있습니다 reduced와 함께 transduce당신의 트랜스 듀서를 사용하는 수, map, filter그것은 당신의 일반적인 질문에 대한 완전한 해답 거리가 멀다 그러나 등.

이스케이프 연속은 일반화 된 버전의 break 및 return 문입니다. 그것들은 일부 체계 ( call-with-escape-continuation), 공통 리스프 ( block+ return, catch+ throw) 및 심지어 C ( setjmp+ longjmp) 로 직접 구현됩니다 . 표준 구성표 또는 Haskell 및 Scala의 연속 모나드에서 볼 수있는보다 일반적인 구분 또는 무제한 연속을 이스케이프 연속으로 사용할 수도 있습니다.

예를 들어 라켓에서는 다음 let/ec과 같이 사용할 수 있습니다 .

(define (some-calc ls)
  (let/ec break ; let break be an escape continuation
    (foldl (lambda (answer e)
             (let ([answer (+ answer e)])
               (case answer
                 [(10)  (break answer)] ; return answer immediately
                 [(150) (+ answer 100)]
                 [else  answer])))
           0 ls)))

다른 많은 언어들도 예외 처리 형식의 이스케이프 연속과 같은 구문을 가지고 있습니다. Haskell에서는으로 다양한 오류 모나드 중 하나를 사용할 수도 있습니다 foldM. 그것들은 주로 초기 반품을 위해 예외 또는 오류 모나드를 사용하는 오류 처리 구문이기 때문에 일반적으로 문화적으로 받아 들일 수없고 상당히 느릴 수 있습니다.

고차 함수에서 테일 호출로 드롭 다운 할 수도 있습니다.

루프를 사용할 때 루프 바디의 끝에 도달하면 다음 반복으로 자동 입력됩니다. (또는 )로 다음 반복을 일찍 입력 continue하거나 루프를 종료 할 수 있습니다 . 꼬리 호출 (또는 꼬리 재귀를 모방하는 Clojure의 구성)을 사용할 때는 항상 다음 반복을 입력하기 위해 명시적인 호출을해야합니다. 루핑을 멈추려면 재귀 호출을하지 않고 값을 직접 제공하십시오.breakreturnloop

(defn some-calc [coll]
  (loop [answer 0, [e es :as coll] coll]
    (if (empty? coll)
      answer
      (let [answer (+ answer e)]
        (case answer
          10 answer
          150 (recur (+ answer 100) es)
          (recur answer es))))))

복잡한 부분은 루프입니다. 시작하겠습니다. 루프는 일반적으로 단일 함수로 반복을 표현하여 기능적 스타일로 변환됩니다. 반복은 루프 변수의 변환입니다.

다음은 일반적인 루프의 기능적 구현입니다.

loop : v -> (v -> v) -> (v -> Bool) -> v
loop init iter cond_to_cont = 
    if cond_to_cont init 
        then loop (iter init) iter cond
        else init

(루프 변수의 초기 값, [루프 변수에서] 단일 반복을 표현하는 함수) (루프를 계속하기위한 조건)를 취합니다.

귀하의 예제는 배열에서 루프를 사용하며, 이는 또한 중단됩니다. 명령형 언어의이 기능은 언어 자체로 구워집니다. 기능적 프로그래밍에서 이러한 기능은 일반적으로 라이브러리 수준에서 구현됩니다. 가능한 구현은 다음과 같습니다

module Array (foldlc) where

foldlc : v -> (v -> e -> v) -> (v -> Bool) -> Array e -> v
foldlc init iter cond_to_cont arr = 
    loop 
        (init, 0)
        (λ (val, next_pos) -> (iter val (at next_pos arr), next_pos + 1))
        (λ (val, next_pos) -> and (cond_to_cont val) (next_pos < size arr))

그것에서 :

외부에서 볼 수있는 루프 변수 와이 함수가 숨기는 배열의 위치를 ​​포함하는 ((val, next_pos)) 쌍을 사용합니다.

반복 함수는 일반 루프보다 약간 더 복잡합니다.이 버전에서는 배열의 현재 요소를 사용할 수 있습니다. [ 카레 형태입니다.]

이러한 기능은 일반적으로 "fold"라고합니다.

배열 요소의 누적이 왼쪽 연관 방식으로 수행됨을 나타 내기 위해 이름에 "l"을 넣습니다. 배열을 낮은 인덱스에서 높은 인덱스로 반복하는 명령형 프로그래밍 언어의 습관을 모방합니다.

이름에 "c"를 붙여이 버전의 접기가 루프를 조기에 중지할지 여부와시기를 제어하는 ​​조건을 취함을 나타냅니다.

물론 이러한 유틸리티 기능은 사용 된 기능적 프로그래밍 언어와 함께 제공되는 기본 라이브러리에서 쉽게 사용할 수 있습니다. 시연을 위해 여기에 썼습니다.

우리는 명령적인 경우에 언어로 된 모든 도구를 가지고 있으므로 예제의 특정 기능을 구현할 수 있습니다.

루프의 변수는 쌍입니다 ( 'answer', 계속할지 여부를 인코딩하는 부울 값).

iter : (Int, Bool) -> Int -> (Int, Bool)
iter (answer, cont) collection_element = 
  let new_answer = answer + collection_element
  in case new_answer of
    10 -> (new_answer, false)
    150 -> (new_answer + 100, true)
    _ -> (new_answer, true)

새로운 "변수" 'new_answer'를 사용했습니다. 함수형 프로그래밍에서는 이미 초기화 된 "변수"의 값을 변경할 수 없기 때문입니다. 성능에 대해 걱정하지 않아도됩니다. 컴파일러는 수명 분석을 통해 '신규 _ 응답'에 대한 '응답'의 메모리를 더 효율적으로 사용할 수 있습니다.

이것을 이전에 개발 한 루프 함수에 통합 :

doSomeCalc :: Array Int -> Int
doSomeCalc arr = fst (Array.foldlc (0, true) iter snd arr)

여기서 "배열"은 foldlc 함수를 내보내는 모듈 이름입니다.

"fist", "second"는 쌍 매개 변수의 첫 번째, 두 번째 구성 요소를 리턴하는 함수를 나타냅니다.

fst : (x, y) -> x
snd : (x, y) -> y

이 경우 "point-free"스타일은 doSomeCalc 구현의 가독성을 향상시킵니다.

doSomeCalc = Array.foldlc (0, true) iter snd >>> fst

(>>>)는 함수 구성입니다. (>>>) : (a -> b) -> (b -> c) -> (a -> c)

위와 동일하며 정의 방정식의 양쪽에서 "arr"매개 변수 만 제외됩니다.

마지막으로 : 대소 문자 확인 (배열 == null). 더 나은 디자인의 프로그래밍 언어에서는 기본 훈련이있는 나쁜 디자인의 언어에서도 선택적 유형 을 사용하여 존재하지 않는 것을 표현합니다. 이것은 함수형 프로그래밍과는 관련이 없으며 궁극적으로 문제는 처리되지 않습니다.

먼저 루프의 각 반복이 조기 종료되거나 answer정확히 한 번만 변경 되도록 루프를 약간 다시 작성하십시오 .

    public int doSomeCalc(int[] array)
    {
        int answer = 0;
        if(array!=null)
        {
            for(int e: array)
            {
                if(answer + e == 10) return answer + e;
                else if(answer + e == 150) answer = answer + e + 100;
                else answer = answer + e;
            }
        }
        return answer;
    }

이 버전의 동작은 이전과 정확히 동일하지만 이제 재귀 스타일로 변환하는 것이 훨씬 간단합니다. 직접 Haskell 번역은 다음과 같습니다.

doSomeCalc :: [Int] -> Int
doSomeCalc = recurse 0
  where recurse :: Int -> [Int] -> Int
        recurse answer [] = answer
        recurse answer (e:array)
          | answer + e == 10 = answer + e
          | answer + e == 150 = recurse (answer + e + 100) array
          | otherwise = recurse (answer + e) array

이제 순전히 기능적이지만 명시 적 재귀 대신 폴드를 사용하여 효율성과 가독성 관점에서 향상시킬 수 있습니다.

import Control.Monad (foldM)

doSomeCalc :: [Int] -> Int
doSomeCalc = either id id . foldM go 0
  where go :: Int -> Int -> Either Int Int
        go answer e
          | answer + e == 10 = Left (answer + e)
          | answer + e == 150 = Right (answer + e + 100)
          | otherwise = Right (answer + e)

이와 관련 Left하여, 가치가있는 조기 종료 및 가치가 Right있는 재귀를 계속합니다.

이제 다음과 같이 조금 더 단순화 할 수 있습니다.

import Control.Monad (foldM)

doSomeCalc :: [Int] -> Int
doSomeCalc = either id id . foldM go 0
  where go :: Int -> Int -> Either Int Int
        go answer e
          | answer' == 10 = Left 10
          | answer' == 150 = Right 250
          | otherwise = Right answer'
          where answer' = answer + e

이것은 최종 Haskell 코드보다 낫지 만 이제는 원래 Java로 다시 매핑되는 방법이 약간 명확하지 않습니다.