복붙노트

[SCALA] 배와 foldLeft 또는 foldRight의 차이?

SCALA

배와 foldLeft 또는 foldRight의 차이?

참고 : 나는 스칼라에 문제가 있음을 2.8 캔입니까?

이유는 배 기능 foldLeft 또는 foldRight와 같은 방법을 사용할 수 없습니다?

설정 scaladoc에서는 그 말한다 :

하지만 함수 서명에 T 매개 변수에 유형을 볼 수 없습니다 :

def fold [A1 >: A] (z: A1)(op: (A1, A1) ⇒ A1): A1

무엇 foldLeft 오른쪽과 배 사이의 차이는, 어떻게 나는 후자를 사용합니까?

편집 : 예를 들어 어떻게이이 목록에있는 모든 요소를 ​​추가 접어 작성합니다? foldLeft으로는 다음과 같습니다

val foo = List(1, 2, 3)
foo.foldLeft(0)(_ + _)

// now try fold:
foo.fold(0)(_ + _)
>:7: error: value fold is not a member of List[Int]
  foo.fold(0)(_ + _)
    ^

해결법

  1. ==============================

    1.당신은 스칼라가 문제가되는 이전 버전에 대한 맞아요. 당신이 스칼라 2.8.1에 대한 scaladoc 페이지를 보면, 당신은 (당신의 오류 메시지와 일치하는) 더 배가 정의 볼 수 있습니다. 분명히, 배 스칼라 2.9에 도입되었다.

    당신은 스칼라가 문제가되는 이전 버전에 대한 맞아요. 당신이 스칼라 2.8.1에 대한 scaladoc 페이지를 보면, 당신은 (당신의 오류 메시지와 일치하는) 더 배가 정의 볼 수 있습니다. 분명히, 배 스칼라 2.9에 도입되었다.

  2. ==============================

    2.짧은 답변:

    짧은 답변:

    오른쪽 foldRight 연결합니다. 즉 요소 피 좌우 순서대로 축적한다 :

    List(a,b,c).foldRight(z)(f) = f(a, f(b, f(c, z)))
    

    왼쪽 foldLeft 연결합니다. 즉 누산기는 초기화되고 소자에 축적에 추가 될 순서는 왼쪽에서 오른쪽으로의 순서 :

    List(a,b,c).foldLeft(z)(f) = f(f(f(z, a), b), c)
    

    스크롤 요소가 함께 추가되는 순서가 정의되지 않은 것을 연관된다. 즉 인수는 모노 이드 형태로 접을 수 있습니다.

  3. ==============================

    3., 배 foldRight 및 foldLeft는 달리, 컬렉션의 요소가 처리되는 순서에 대한 보증을 제공하지 않습니다. 당신은 아마 보증 처리 순서의 부족은 병렬 방식으로 접는 병렬 컬렉션을 구현하는 데 도움이 병렬 컬렉션으로, 그것의 더 제약 서명, 배 사용할 수 있습니다. 서명을 변경하는 이유는 비슷하다 추가적인 제약, 그것은 병렬 접을 수 있도록하는 것이 더 쉽습니다.

    , 배 foldRight 및 foldLeft는 달리, 컬렉션의 요소가 처리되는 순서에 대한 보증을 제공하지 않습니다. 당신은 아마 보증 처리 순서의 부족은 병렬 방식으로 접는 병렬 컬렉션을 구현하는 데 도움이 병렬 컬렉션으로, 그것의 더 제약 서명, 배 사용할 수 있습니다. 서명을 변경하는 이유는 비슷하다 추가적인 제약, 그것은 병렬 접을 수 있도록하는 것이 더 쉽습니다.

  4. ==============================

    4.특정 예를 들어, 당신은 그에게 당신이 foldLeft 때와 같은 방식으로 코드를 것입니다.

    특정 예를 들어, 당신은 그에게 당신이 foldLeft 때와 같은 방식으로 코드를 것입니다.

    val ns = List(1, 2, 3, 4)
    val s0 = ns.foldLeft (0) (_+_) //10
    val s1 = ns.fold (0) (_+_) //10
    assert(s0 == s1)
    
  5. ==============================

    5.다른 답변에 동의합니다. 간단한 예시를주는 생각 :

    다른 답변에 동의합니다. 간단한 예시를주는 생각 :

     object MyClass {
     def main(args: Array[String]) {
    val numbers = List(5, 4, 8, 6, 2)
     val a =  numbers.fold(0) { (z, i) =>
     {
         println("fold val1 " + z +" val2 " + i)
      z + i
    
     }
    }
    println(a)
     val b =  numbers.foldLeft(0) { (z, i) =>
     println("foldleft val1 " + z +" val2 " + i)
      z + i
    
    }
    println(b)
       val c =  numbers.foldRight(0) { (z, i) =>
       println("fold right val1 " + z +" val2 " + i)
      z + i
    
    }
    println(c)
     }
    }
    
    fold val1 0 val2 5
    fold val1 5 val2 4
    fold val1 9 val2 8
    fold val1 17 val2 6
    fold val1 23 val2 2
    25
    foldleft val1 0 val2 5
    foldleft val1 5 val2 4
    foldleft val1 9 val2 8
    foldleft val1 17 val2 6
    foldleft val1 23 val2 2
    25
    fold right val1 2 val2 0
    fold right val1 6 val2 2
    fold right val1 8 val2 8
    fold right val1 4 val2 16
    fold right val1 5 val2 20
    25
    
  6. ==============================

    6.상기 처리 순서를 보장하지 않도록 병렬 처리를 수행) (폴드. 여기서 (foldLeft의 경우) 왼쪽에서 오른쪽으로 또는 오른쪽 (foldRight의 경우)에 대해 좌측에 foldLeft 및 foldRight는 항목을 순차적으로 처리

    상기 처리 순서를 보장하지 않도록 병렬 처리를 수행) (폴드. 여기서 (foldLeft의 경우) 왼쪽에서 오른쪽으로 또는 오른쪽 (foldRight의 경우)에 대해 좌측에 foldLeft 및 foldRight는 항목을 순차적으로 처리

    합 목록의 예 -

    val numList = List(1, 2, 3, 4, 5)
    
    val r1 = numList.par.fold(0)((acc, value) => {
      println("adding accumulator=" + acc + ", value=" + value + " => " + (acc + value))
      acc + value
    })
    println("fold(): " + r1)
    println("#######################")
    /*
     * You can see from the output that,
     * fold process the elements of parallel collection in parallel
     * So it is parallel not linear operation.
     * 
     * adding accumulator=0, value=4 => 4
     * adding accumulator=0, value=3 => 3
     * adding accumulator=0, value=1 => 1
     * adding accumulator=0, value=5 => 5
     * adding accumulator=4, value=5 => 9
     * adding accumulator=0, value=2 => 2
     * adding accumulator=3, value=9 => 12
     * adding accumulator=1, value=2 => 3
     * adding accumulator=3, value=12 => 15
     * fold(): 15
     */
    
    val r2 = numList.par.foldLeft(0)((acc, value) => {
      println("adding accumulator=" + acc + ", value=" + value + " => " + (acc + value))
      acc + value
    })
    println("foldLeft(): " + r2)
    println("#######################")
    /*
     * You can see that foldLeft
     * picks elements from left to right.
     * It means foldLeft does sequence operation
     * 
     * adding accumulator=0, value=1 => 1
     * adding accumulator=1, value=2 => 3
     * adding accumulator=3, value=3 => 6
     * adding accumulator=6, value=4 => 10
     * adding accumulator=10, value=5 => 15
     * foldLeft(): 15
     * #######################
     */
    
    // --> Note in foldRight second arguments is accumulated one.
    val r3 = numList.par.foldRight(0)((value, acc) => {
     println("adding value=" + value + ", acc=" + acc + " => " + (value + acc))
      acc + value
    })
    println("foldRight(): " + r3)
    println("#######################")
    
    /*
     * You can see that foldRight
     * picks elements from right to left.
     * It means foldRight does sequence operation.
     * 
     * adding value=5, acc=0 => 5
     * adding value=4, acc=5 => 9
     * adding value=3, acc=9 => 12
     * adding value=2, acc=12 => 14
     * adding value=1, acc=14 => 15
     * foldRight(): 15
     * #######################
     */
    
  7. from https://stackoverflow.com/questions/6253978/difference-between-fold-and-foldleft-or-foldright by cc-by-sa and MIT license