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

배와 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
    * #######################
    */
   

from https://stackoverflow.com/questions/6253978/difference-between-fold-and-foldleft-or-foldright by cc-by-sa and MIT license