blocks|key|266121|text|您说得对，旧版本的Scala是个问题。如果您查看Scala2.8.1的scaladoc+page，您将看到没有定义任何文件夹(这与您的错误消息一致)。显然，fold是在Scala2.9中引入的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|266122|entityMap|0|LINK|mutability|MUTABLE|url|http://www.scala-lang.org/api/2.8.1//scala/collection/immutable/Set.html^0|26|4|Z|D|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

You're right about the old version of Scala being a problem. If you look at the <a href="http://www.scala-lang.org/api/2.8.1//scala/collection/immutable/Set.html" rel="noreferrer">scaladoc page</a> for Scala 2.8.1, you'll see no fold defined there (which is consistent with your error message). Apparently, <code>fold</code> was introduced in Scala 2.9.

blocks|key|266089|text|简短的回答：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|266090|右边是foldRight+associates。即元素将按从右到左的顺序累积：|offset|length|style|CODE|266091|List(a,b,c).foldRight(z)(f)+=+f(a,+f(b,+f(c,+z)))|code-block|syntax|javascript|266092|foldLeft关联在左侧。即，一个累加器将被初始化，元素将按从左到右的顺序添加到累加器：|266093|List(a,b,c).foldLeft(z)(f)+=+f(f(f(z,+a),+b),+c)|266094|fold是关联的，因为没有定义元素添加到一起的顺序。也就是说，fold的参数形成一个。|266095|entityMap^0|0|3|9|0|0|0|8|0|0|0|4|V|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|13|8|@$D|14|E|15|F|G]|$D|16|E|17|F|G]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|T|$]]

Short answer:

<code>foldRight</code> associates to the right. I.e. elements will be accumulated in right-to-left order:

<pre><code>List(a,b,c).foldRight(z)(f) = f(a, f(b, f(c, z)))
</code></pre>

<code>foldLeft</code> associates to the left. I.e. an accumulator will be initialized and elements will be added to the accumulator in left-to-right order:

<pre><code>List(a,b,c).foldLeft(z)(f) = f(f(f(z, a), b), c)
</code></pre>

<code>fold</code> is associative in that the order in which the elements are added together is not defined. I.e. the arguments to <code>fold</code> form a <a href="http://en.wikipedia.org/wiki/Monoid">monoid</a>.

blocks|key|2961241|text|与foldRight和foldLeft相反，fold不提供任何关于集合元素的处理顺序的保证。您可能希望对并行集合使用具有更多约束签名的fold，其中缺乏有保证的处理顺序有助于并行集合以并行方式实现折叠。更改签名的原因是相似的:有了额外的约束，更容易进行并行折叠。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2961242|entityMap^0|1|9|B|8|M|4|1V|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

<code>fold</code>, contrary to <code>foldRight</code> and <code>foldLeft</code>, does not offer any guarantee about the order in which the elements of the collection will be processed. You'll probably want to use <code>fold</code>, with its more constrained signature, with parallel collections, where the lack of guaranteed processing order helps the parallel collection implements folding in a parallel way. The reason for changing the signature is similar: with the additional constraints, it's easier to make a parallel fold.

blocks|key|2961334|text|对于您的特定示例，您将使用与foldLeft相同的方式对其进行编码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2961335|val+ns+=+List(1,+2,+3,+4)
val+s0+=+ns.foldLeft+(0)+(_%2B_)+//10
val+s1+=+ns.fold+(0)+(_%2B_)+//10
assert(s0+==+s1)|code-block|syntax|javascript|2961336|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For your particular example you would code it the same way you would with foldLeft.

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

blocks|key|269282|text|同意其他答案。想给出一个简单的说明性例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|269283|+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+"+%2B+z+%2B"+val2+"+%2B+i)
++z+%2B+i

+}
}
println(a)
+val+b+=++numbers.foldLeft(0)+{+(z,+i)+=>
+println("foldleft+val1+"+%2B+z+%2B"+val2+"+%2B+i)
++z+%2B+i

}
println(b)
+++val+c+=++numbers.foldRight(0)+{+(z,+i)+=>
+++println("fold+right+val1+"+%2B+z+%2B"+val2+"+%2B+i)
++z+%2B+i

}
println(c)
+}
}|code-block|syntax|javascript|269284|结果不言而喻：|269285|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|269286|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Agree with other answers. thought of giving a simple illustrative example: 

<pre><code> object MyClass {
 def main(args: Array[String]) {
val numbers = List(5, 4, 8, 6, 2)
 val a = numbers.fold(0) { (z, i) =&gt;
 {
 println("fold val1 " + z +" val2 " + i)
 z + i

 }
}
println(a)
 val b = numbers.foldLeft(0) { (z, i) =&gt;
 println("foldleft val1 " + z +" val2 " + i)
 z + i

}
println(b)
 val c = numbers.foldRight(0) { (z, i) =&gt;
 println("fold right val1 " + z +" val2 " + i)
 z + i

}
println(c)
 }
}
</code></pre>

<h3>Result is self explanatory :</h3>

<pre><code>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
</code></pre>

blocks|key|267569|text|有两种方法可以解决问题，迭代和递归。让我们通过一个简单的例子来理解。让我们写一个函数来求和直到给定的数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|267570|例如，如果我将输入设为5，我应该得到15作为输出，如下所述。|267571|输入：5|offset|length|style|BOLD|267572|输出：(1%2B2%2B3%2B4%2B5)+=+15|267573|迭代解。|267574|遍历1到5，并对每个元素求和。|267575|++def+sumNumber(num:+Int):+Long+=+{
++++var+sum=0
++++for(i+<-+1+to+num){
++++++sum%2B=i
++++}
++++sum
++}|code-block|syntax|javascript|267576|递归解决方案|267577|将较大的问题分解为较小的问题并解决它们。|267578|++def+sumNumberRec(num:Int,+sum:Int=0):+Long+=+{
++++if(num+==+0){
++++++sum
++++}else{
++++++val+newNum+=+num+-+1
++++++val+newSum+=+sum+%2B+num
++++++sumNumberRec(newNum,+newSum)
++++}
++}|267579|267580|+FoldLeft：是一种迭代解决方案|blockquote|267581|267582|FoldRight：是一个递归解决方案，我不确定他们是否有记忆体来提高复杂性。|267583|因此，如果您在较小的列表上运行foldRight和FoldLeft，两者都会给出性能相似的结果。|267584|但是，如果您尝试在Long+List上运行FoldRight，可能会抛出一个错误(取决于您的内存)|CODE|267585|检查下面的屏幕截图，其中foldLeft运行没有错误，但是同一列表中的foldRight给出了OutofMemmory错误。|267586|​|267587|📷|atomic|267588|267589|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/82e9ef92339557abbc6d2bc9d5953d6e.png|imageAlt^0|0|0|0|2|0|0|2|0|0|4|0|0|0|0|6|0|0|0|0|1|8|0|0|0|9|0|0|9|9|12|B|L|9|0|0|1Q|C|8|Z|9|1B|C|0|0|1|0|0|1|0|1|0|0|0|1|0^^$0|@$1|2|3|4|5|6|7|1T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1V|8|@$F|1W|G|1X|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1Y|8|@$F|1Z|G|20|H|I]]|9|@]|A|$]]|$1|L|3|M|5|6|7|21|8|@$F|22|G|23|H|I]]|9|@]|A|$]]|$1|N|3|O|5|6|7|24|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|25|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|26|8|@$F|27|G|28|H|I]]|9|@]|A|$]]|$1|W|3|X|5|6|7|29|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|R|7|2A|8|@]|9|@]|A|$S|T]]|$1|10|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|11|3|12|5|13|7|2C|8|@$F|2D|G|2E|H|I]]|9|@]|A|$]]|$1|14|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|2G|8|@$F|2H|G|2I|H|I]]|9|@]|A|$]]|$1|17|3|18|5|6|7|2J|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|2K|8|@$F|2L|G|2M|H|I]|$F|2N|G|2O|H|I]|$F|2P|G|2Q|H|1B]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2R|8|@$F|2S|G|2T|H|I]|$F|2U|G|2V|H|1B]|$F|2W|G|2X|H|1B]|$F|2Y|G|2Z|H|1B]]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|30|8|@$F|31|G|32|H|I]]|9|@]|A|$]]|$1|1G|3|1H|5|1I|7|33|8|@$F|34|G|35|H|I]]|9|@$F|36|G|37|1|38]]|A|$]]|$1|1J|3|1F|5|6|7|39|8|@$F|3A|G|3B|H|I]]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|3C|8|@]|9|@]|A|$]]]|1L|$1M|$5|1N|1O|1P|A|$1Q|1R|1S|-4]]]]

There is two way to solve problems, iterative and recursive. Let's understand by a simple example.let's write a function to sum till the given number.

For example if I give input as 5, I should get 15 as output, as mentioned below. 

Input: 5 

Output: (1+2+3+4+5) = 15

Iterative Solution. 

iterate through 1 to 5 and sum each element. 

<pre><code> def sumNumber(num: Int): Long = {
 var sum=0
 for(i &lt;- 1 to num){
 sum+=i
 }
 sum
 }
</code></pre>

Recursive Solution

break down the bigger problem into smaller problems and solve them. 

<pre><code> def sumNumberRec(num:Int, sum:Int=0): Long = {
 if(num == 0){
 sum
 }else{
 val newNum = num - 1
 val newSum = sum + num
 sumNumberRec(newNum, newSum)
 }
 }
</code></pre>

<blockquote>
 <blockquote>
 FoldLeft: is a iterative solution 
 
 FoldRight: is a recursive solution 
 I am not sure if they have memoization to improve the complexity.
 </blockquote>
</blockquote>

And so, if you run the foldRight and FoldLeft on the small list, both will give you a result with similar performance. 

However, if you will try to run a <code>FoldRight</code> on Long List it might throw a StackOverFlow error (depends on your memory) 

Check the following screenshot, where <code>foldLeft</code> ran without error, however <code>foldRight</code> on same list gave <code>OutofMemmory</code> Error. 

<a href="https://i.stack.imgur.com/7kTbg.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/7kTbg.png" alt="enter image description here"></a>

blocks|key|267540|text|fold()进行并行处理，因此不能保证处理顺序。其中，as+foldLeft和foldRight按从左到右(在foldLeft中)或从右到左(在foldRight中)的顺序处理项|type|unstyled|depth|inlineStyleRanges|entityRanges|data|267541|对列表求和的示例：|267542|val+numList+=+List(1,+2,+3,+4,+5)

val+r1+=+numList.par.fold(0)((acc,+value)+=>+{
++println("adding+accumulator="+%2B+acc+%2B+",+value="+%2B+value+%2B+"+=>+"+%2B+(acc+%2B+value))
++acc+%2B+value
})
println("fold():+"+%2B+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="+%2B+acc+%2B+",+value="+%2B+value+%2B+"+=>+"+%2B+(acc+%2B+value))
++acc+%2B+value
})
println("foldLeft():+"+%2B+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="+%2B+value+%2B+",+acc="+%2B+acc+%2B+"+=>+"+%2B+(value+%2B+acc))
++acc+%2B+value
})
println("foldRight():+"+%2B+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
+*+#######################
+*/|code-block|syntax|javascript|267543|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

fold() does parallel processing so does not guarantee the processing order.
where as foldLeft and foldRight process the items in sequentially for left to right (in case of foldLeft) or right to left (in case of foldRight)

Examples of sum the list - 

<pre><code>val numList = List(1, 2, 3, 4, 5)

val r1 = numList.par.fold(0)((acc, value) =&gt; {
 println("adding accumulator=" + acc + ", value=" + value + " =&gt; " + (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 =&gt; 4
 * adding accumulator=0, value=3 =&gt; 3
 * adding accumulator=0, value=1 =&gt; 1
 * adding accumulator=0, value=5 =&gt; 5
 * adding accumulator=4, value=5 =&gt; 9
 * adding accumulator=0, value=2 =&gt; 2
 * adding accumulator=3, value=9 =&gt; 12
 * adding accumulator=1, value=2 =&gt; 3
 * adding accumulator=3, value=12 =&gt; 15
 * fold(): 15
 */

val r2 = numList.par.foldLeft(0)((acc, value) =&gt; {
 println("adding accumulator=" + acc + ", value=" + value + " =&gt; " + (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 =&gt; 1
 * adding accumulator=1, value=2 =&gt; 3
 * adding accumulator=3, value=3 =&gt; 6
 * adding accumulator=6, value=4 =&gt; 10
 * adding accumulator=10, value=5 =&gt; 15
 * foldLeft(): 15
 * #######################
 */

// --&gt; Note in foldRight second arguments is accumulated one.
val r3 = numList.par.foldRight(0)((value, acc) =&gt; {
 println("adding value=" + value + ", acc=" + acc + " =&gt; " + (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 =&gt; 5
 * adding value=4, acc=5 =&gt; 9
 * adding value=3, acc=9 =&gt; 12
 * adding value=2, acc=12 =&gt; 14
 * adding value=1, acc=14 =&gt; 15
 * foldRight(): 15
 * #######################
 */
</code></pre>

NOTE: I am on Scala 2.8—can that be a problem?

Why can't I use the <code>fold</code> function the same way as <code>foldLeft</code> or <code>foldRight</code>?

In the <a href="http://www.scala-lang.org/api/current/scala/collection/immutable/Set.html">Set scaladoc</a> it says that:

<blockquote>
 The result of folding may only be a supertype of this parallel collection's type parameter <code>T</code>.
</blockquote>

But I see no type parameter <code>T</code> in the function signature:

<pre><code>def fold [A1 &gt;: A] (z: A1)(op: (A1, A1) ⇒ A1): A1
</code></pre>

What is the difference between the <code>foldLeft-Right</code> and <code>fold</code>, and how do I use the latter?

EDIT: For example how would I write a fold to add all elements in a list? With <code>foldLeft</code> it would be:

<pre><code>val foo = List(1, 2, 3)
foo.foldLeft(0)(_ + _)

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

Difference between fold and foldLeft or foldRight?

注意:我使用的是Scala2.8--这有问题吗？为什么我不能像使用foldLeft或foldRight一样使用fold函数在中，它说：折叠的结果只能是此并行集合的类型参数T的超类型。但我在函数签名中看不到类型参数T：def fold [A1 >: A] (z: A1)(op: (A1, A1) ⇒ A1): A1foldLeft-Right和fold有什么区别，如何使用后者？编辑:例如，我如何编写

问fold和foldLeft还是foldRight之间的区别？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问fold和foldLeft还是foldRight之间的区别？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问fold和foldLeft还是foldRight之间的区别？
EN