I am trying to filter all the elements in an array which are bigger than 10 to a new array. I am intentionally not using `Array.prototype.filter()` since I want to learn the `reduce()` method. Here is the code I was playing with

&lt;!-- begin snippet: js hide: false --&gt;

&lt;!-- language: lang-js --&gt;

    var collection = [3, 5, 11, 23, 1];

    // fileter all the elements bigger than 10 to a new array

    var output = collection.reduce(function(filteredArr, collectionElemet) {
      if (collectionElemet &gt; 10) {
        return filteredArr.push(collectionElemet);
      }
    }, []);

&lt;!-- end snippet --&gt;

I was expecting that `filteredArr` would be initialized with an empty array at the time of first callback execution as it happens with many examples provided [here][1]. But when I run this code, I get the error
`Cannot read property &#39;push&#39; of undefined`, where am I messing it up? Thank you!


  [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

Why Array.prototype.reduce() is not taking an empty array as accumulator?

Code speaks better than language, so:

```
[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;].reduce((accumulator, value) =&gt; accumulator.concat(value), []);
```

The code is very silly and returns a copied Array...

TS complains on concat&#39;s argument: TS2345: Argument of type &#39;string&#39; is not assignable to parameter of type &#39;ConcatArray&lt;never&gt;&#39;.



Why does TypeScript infer the &#39;never&#39; type when reducing an Array with concat?

I am trying to understand how fold and foldLeft and the respective reduce and reduceLeft work. I used fold and foldLeft as my example

    scala&gt; val r = List((ArrayBuffer(1, 2, 3, 4),10))
    scala&gt; r.foldLeft(ArrayBuffer(1,2,4,5))((x,y) =&gt; x -- y._1)
    
    scala&gt; res28: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(5)
    
    scala&gt; r.fold(ArrayBuffer(1,2,4,5))((x,y) =&gt; x -- y._1)
    &lt;console&gt;:11: error: value _1 is not a member of Serializable with Equals
                  r.fold(ArrayBuffer(1,2,4,5))((x,y) =&gt; x -- y._1)
       
Why `fold` didn&#39;t work as `foldLeft`? What is `Serializable with Equals`? I understand fold and foldLeft has slight different API signature in terms of parameter generic types. Please advise. Thanks.

Scala : fold vs foldLeft

There is nice Array method [`reduce()`][1] to get one value from the Array. Example:

    [0,1,2,3,4].reduce(function(previousValue, currentValue, index, array){
      return previousValue + currentValue;
    });

What is the best way to achieve the same with objects? I&#39;d like to do this:

    { 
        a: {value:1}, 
        b: {value:2}, 
        c: {value:3} 
    }.reduce(function(previous, current, index, array){
      return previous.value + current.value;
    });

However, Object does not seem to have any `reduce()` method implemented.

  [1]: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/Reduce

Javascript reduce() on Object

I&#39;m using Python 3.2. Tried this:

    xor = lambda x,y: (x+y)%2
    l = reduce(xor, [1,2,3,4])
And got the following error:

    l = reduce(xor, [1,2,3,4])
    NameError: name &#39;reduce&#39; is not defined

Tried printing `reduce` into interactive console - got this error:

    NameError: name &#39;reduce&#39; is not defined

&lt;br&gt;
Is `reduce` really removed in Python 3.2? If that&#39;s the case, what&#39;s the alternative?

NameError: name &#39;reduce&#39; is not defined in Python

Is there any way to `map`/`reduce`/`filter`/etc a `Set` in JavaScript or will I have to write my own?

Here&#39;s some sensible `Set.prototype` extensions

    Set.prototype.map = function map(f) {
      var newSet = new Set();
      for (var v of this.values()) newSet.add(f(v));
      return newSet;
    };
    
    Set.prototype.reduce = function(f,initial) {
      var result = initial;
      for (var v of this) result = f(result, v);
      return result;
    };
    
    Set.prototype.filter = function filter(f) {
      var newSet = new Set();
      for (var v of this) if(f(v)) newSet.add(v);
      return newSet;
    };
    
    Set.prototype.every = function every(f) {
      for (var v of this) if (!f(v)) return false;
      return true;
    };
    
    Set.prototype.some = function some(f) {
      for (var v of this) if (f(v)) return true;
      return false;
    };

Let&#39;s take a little set

    let s = new Set([1,2,3,4]);

And some stupid little functions

    const times10 = x =&gt; x * 10;
    const add = (x,y) =&gt; x + y;
    const even = x =&gt; x % 2 === 0;

And see how they work

    s.map(times10);    //=&gt; Set {10,20,30,40}
    s.reduce(add, 0);  //=&gt; 10
    s.filter(even);    //=&gt; Set {2,4}
    s.every(even);     //=&gt; false
    s.some(even);      //=&gt; true

&gt; Isn&#39;t that nice ? Yeah, I think so too. Compare that to the ugly iterator usage

    // puke
    let newSet = new Set();
    for (let v in s) {
      newSet.add(times10(v));
    }

And

    // barf
    let sum = 0;
    for (let v in s) {
      sum = sum + v;
    }

Is there any better way to accomplish `map` and `reduce` using a `Set` in JavaScript?

How to map/reduce/filter a Set in JavaScript?

When should I use `reduceLeft`, `reduceRight`, `foldLeft`, `foldRight`, `scanLeft` or `scanRight`?

I want an intuition/overview of their differences - possibly with some simple examples.

Reduce, fold or scan (Left/Right)?

I am pretty confused with both functions `fold()` and `reduce()` in Kotlin, can anyone give me a concrete example that distinguishes both of them? 

Difference between fold and reduce in Kotlin, When to use which?

What is the most idiomatic way to achieve something like the following, in Haskell:

    foldl (+) 0 [1,2,3,4,5]
    --&gt; 15

Or its equivalent in Ruby:

    [1,2,3,4,5].inject(0) {|m,x| m + x}
    #&gt; 15

Obviously, Python provides the `reduce` function, which is an implementation of fold, exactly as above, however, I was told that the &#39;pythonic&#39; way of programming was to avoid `lambda` terms and higher-order functions, preferring list-comprehensions where possible. Therefore, is there a preferred way of folding a list, or list-like structure in Python that isn&#39;t the `reduce` function, or is `reduce` the idiomatic way of achieving this?



What is the &#39;pythonic&#39; equivalent to the &#39;fold&#39; function from functional programming?

How can I break the iteration of `reduce()` method?

`for`:

    for (var i = Things.length - 1; i &gt;= 0; i--) {
      if(Things[i] &lt;= 0){
        break;
      }
    };

`reduce()`
    
    Things.reduce(function(memo, current){
      if(current &lt;= 0){
        //break ???
        //return; &lt;-- this will return undefined to memo, which is not what I want
      }
    }, 0)


How to early break reduce() method?

I have to find the average of a list in Python. This is my code so far

    from functools import reduce

    l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
    print(reduce(lambda x, y: x + y, l))

I&#39;ve got it so it adds together the values in the list, but I don&#39;t know how to make it divide into them?

Finding the average of a list

Trying to learn F# but got confused when trying to distinguish between [fold][1] and [reduce][2]. Fold seems to do the [same thing][3] but takes an extra parameter. Is there a legitimate reason for these two functions to exist or they are there to accommodate people with different backgrounds? (E.g.: String and string in C#)

Here is code snippet copied from sample:

    let sumAList list =
        List.reduce (fun acc elem -&gt; acc + elem) list

    let sumAFoldingList list =
        List.fold (fun acc elem -&gt; acc + elem) 0 list

    printfn &quot;Are these two the same? %A &quot; 
                 (sumAList [2; 4; 10] = sumAFoldingList [2; 4; 10])

  [1]: http://msdn.microsoft.com/en-us/library/ee353894.aspx
  [2]: http://msdn.microsoft.com/en-us/library/ee370239.aspx
  [3]: https://stackoverflow.com/questions/3682371/accumulate-vs-fold-vs-reduce-vs-compress

Difference between fold and reduce?

Seem to be having some issues incorporating async/await with .reduce(), like so:

    const data = await bodies.reduce(async(accum, current, index) =&gt; {
      const methodName = methods[index]
      const method = this[methodName]
      if (methodName == &#39;foo&#39;) {
        current.cover = await this.store(current.cover, id)
        console.log(current)
        return {
          ...accum,
          ...current
        }
      }
      return {
        ...accum,
        ...method(current.data)
      }
    }, {})
    console.log(data)

The `data` object is logged *before* the `this.store` completes...

I know you can utilise `Promise.all` with async loops, but does that apply to `.reduce()`?

JavaScript array .reduce with async/await

I used both methods but I am quite confused regarding the usage of both methods.
 
Is anything that `map` can do but `reduce` can not and vice versa?

Note: I know how to use both methods I am questioning for main difference between these method and when we need to used.

Main difference between map and reduce

I saw that they were documented together [here][1]. Are they the same thing? Why does Ruby have so many aliases (such as map/collect for arrays)? Thanks a lot.


  [1]: http://ruby-doc.org/core-1.9.3/Enumerable.html#method-i-reduce

Is inject the same thing as reduce in ruby?

I am trying to reduce an array of objects to a set in Swift and this is my code:

    objects.reduce(Set&lt;String&gt;()) { $0.insert($1.URL) }

However, I get an error:

    Type of expression is ambiguous without more context.

I do not understand what the problem is, since the type of URL is definitely String. Any ideas?

Reduce array to set in Swift

I found in [MSDN&#39;s Linq samples][1] a neat method called Fold() that I want to use.  Their example:

    double[] doubles = { 1.7, 2.3, 1.9, 4.1, 2.9 }; 
    double product = 
         doubles.Fold((runningProduct, nextFactor) =&gt; runningProduct * nextFactor); 

Unfortunately, I can&#39;t get this to compile, either in their example or in my own code, and I can&#39;t find anywhere else in MSDN (like Enumerable or Array extension methods) that mention this method.  The error I get is a plain old &quot;don&#39;t know anything about that&quot; error:

    error CS1061: &#39;System.Array&#39; does not contain a definition for &#39;Fold&#39; and no 
    extension method &#39;Fold&#39; accepting a first argument of type &#39;System.Array&#39; could 
    be found (are you missing a using directive or an assembly reference?)

I&#39;m using other methods which I believe come from Linq (like Select() and Where()), and I&#39;m &quot;using System.Linq&quot;, so I think that&#39;s all OK.

Does this method really exist in C# 3.5, and if so, what am I doing wrong?


  [1]: http://msdn.microsoft.com/en-us/vcsharp/aa336747.aspx#foldSimple

Where is the &quot;Fold&quot; LINQ Extension Method?

Why do Scala and frameworks like Spark and Scalding have both `reduce` and `foldLeft`? So then what&#39;s the difference between `reduce` and `fold`?

Difference between reduce and foldLeft/fold in functional programming (particularly Scala and Scala APIs)?

In Hadoop when do reduce tasks start? Do they start after a certain percentage (threshold) of mappers complete? If so, is this threshold fixed? What kind of threshold is typically used?

When do reduce tasks start in Hadoop?

`filter`, `map`, and `reduce` work perfectly in Python 2. Here is an example:

    &gt;&gt;&gt; def f(x):
            return x % 2 != 0 and x % 3 != 0
    &gt;&gt;&gt; filter(f, range(2, 25))
    [5, 7, 11, 13, 17, 19, 23]

    &gt;&gt;&gt; def cube(x):
            return x*x*x
    &gt;&gt;&gt; map(cube, range(1, 11))
    [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

    &gt;&gt;&gt; def add(x,y):
            return x+y
    &gt;&gt;&gt; reduce(add, range(1, 11))
    55

But in Python 3, I receive the following outputs:

    &gt;&gt;&gt; filter(f, range(2, 25))
    &lt;filter object at 0x0000000002C14908&gt;

    &gt;&gt;&gt; map(cube, range(1, 11))
    &lt;map object at 0x0000000002C82B70&gt;

    &gt;&gt;&gt; reduce(add, range(1, 11))
    Traceback (most recent call last):
      File &quot;&lt;pyshell#8&gt;&quot;, line 1, in &lt;module&gt;
        reduce(add, range(1, 11))
    NameError: name &#39;reduce&#39; is not defined

I would appreciate if someone could explain to me why this is.

Screenshot of code for further clarity:

[![IDLE sessions of Python 2 and 3 side-by-side](http://i.imgur.com/WekeD.png)](http://i.imgur.com/WekeD.png)

How to use filter, map, and reduce in Python 3

Say I want to sum `a.x` for each element in `arr`.

```js
arr = [ { x: 1 }, { x: 2 }, { x: 4 } ];
arr.reduce(function(a, b){ return a.x + b.x; }); // =&gt; NaN
```

I have cause to believe that `a.x` is `undefined` at some point.

The following works fine

```js
arr = [ 1, 2, 4 ];
arr.reduce(function(a, b){ return a + b; }); // =&gt; 7
```

What am I doing wrong in the first example?

How to call reduce on an array of objects to sum their properties?

Why is it that when I want to use the push function inside the reduce function to return a new array I get an error. However, when I use the concat method inside the reduce function, it returns a new array with no problem.

All I&#39;m trying to do is pass an array to the reduce function and return the same array.

    var store = [0,1,2,3,4];
    
    var stored = store.reduce(function(pV,cV,cI){
      console.log(&quot;pv: &quot;, pV);
      return pV.push(cV);
    },[]);

This returns an error. But when I use concat: 

    var store = [0,1,2,3,4];
    
    var stored = store.reduce(function(pV,cV,cI){
      console.log(&quot;pv: &quot;, pV);
      return pV.concat(cV);
    },[]);

It returns the same array.

Any ideas why?

  

All Reduce Solutions on Gang of Coders

Total of 22 Reduce Solutions