Reduce is a powerful operator that can be used on an array (DataWeave :array datatype).

Reduce can be used to process an :array and operate on each of its elements. It performs an aggregation operation on the elements of the :array after performing a lambda operation (optional) on each of its element.

It can be used to create a String, A Map or an Array. It can also be used as a substitute to the map operator. The :array to :object is also possible via the reduce operator. We use the reduce operator to do this kind of transformation, in addition to various other types.

In this series, I will provide examples of how to use the reduce operator effectively.

For the reduce operations, an accumulator should be chosen according to the aggregate result we want to achieve. Also, the aggregation operator — for example, + (Add), ++ (Concat), * (Multiply), etc. — should be chosen as per requirements. The accumulator can be viewed as the output variable. It contains the output after all the iterations over the array on which reduce is applied. Accumulator should be carefully chosen depending on the type of Output which we want to get. Suppose we want a string as an end result then a string accumulator needs to be taken, if the end result needs to be an array then accumulator should be an Array and so on.

Execute a Simple Arithmetic Sum of a List's Elements 

Let's say the list elements are [10, 20, 30, 40].

• Expected output: 100 (sum of all elements of the array).

• Accumulator: 0 (a number zero is chosen for the addition of subsequent elements).

• Aggregate operation: + (addition).

• Dataweave code: payload reduce $$ + $.

We can execute a lambda over each element of the array to get a modified element and add it continuously to the accumulator.

Perform a More Complex Arithmetic Operation

Input payload (a list):

[{number : 10, times : 8},{number : 2, times : 5},{number : 7, times : 7},{number : 6, times : 3},{number : 4, times : 7}]

Expected output:  185 (sum of each element resulting from "number" multiplied by "times").

Accumulator: 0 (a number zero is chosen for the addition of subsequent elements).

Aggregate operation: + (addition).

Dataweave code:

payload reduce ((val, acc = 0) -> acc + (val.number * val.times))  

Modify a List

Input payload: 

[{"Capital": "New Delhi","Country": "India"}, {"Capital": "Paris","Country": "France"}, {"Capital": "London","Country": "England"}]

Required output:

["India-New Delhi","France-Paris","England-London"] 

Accumulator: [] (an empty array is chosen for addition of subsequent elements resulting from the lambda).

Aggregate operation: + (addition operation to obtain an array of the elements resulting from lambda; this is used to make an array push on the accumulating array using the modified element).

Dataweave code:

payload reduce ((val, acc = []) -> acc + ( (val.Country) ++ "-" ++ val.Capital ))

Note: This can also be done using the map operator.

I hope that this post helps you get started using the reduce operator,

In the next post, I will try to explain and exemplify some scenarios (:array to :object)  using the reduce operator.