I recently had a business problem which required using the "using" operator in Data Weave. I noticed there wasn't a lot of documentation on it so this will be a brief overview of my problem and how the using operator helped me.

The using operator allows us to use a variable in a scope, for example, within a map. This is useful when you need to aggregate a subset of elements in an array. Let's say we have an array with the following elements:

{"letterCountArray": [
{"letter": "A","count": 5},
{"letter": "B","count": 3},
{"letter": "C","count": 6},
{"letter": "D","count": 5},
{"letter": "E","count": 7}]}

Our requirement is to display the letter and count for A, B and C.

We can write the following Data Weave:

result: payload.letterCountArray filter $.letter == "A" or $.letter == "B" 
or $.letter == "C" map {
(letterA: {
   Letter: $.letter,
   Count: $.count
}) when $.letter == "A",
(letterB: {
   Letter: $.letter,
   Count: $.count
}) when $.letter == "B",
(letterC: {
   Letter: $.letter,
   Count: $.count
}) when $.letter == "C"
}

which will give the result

{
  "result": [
    {
      "letterA": {
        "Letter": "A",
        "Count": 5
      }
    },
    {
      "letterB": {
        "Letter": "B",
        "Count": 3
      }
    },
    {
      "letterC": {
        "Letter": "C",
        "Count": 6
      }
    }
  ]
}

Now the user says, I love your program but... I would like to have the sum of E and D counts. A simple solution is to use the using operator. You can create a function to sum the count of D and E and put that into a variable. You can use that variable to display the count within the map.

%function getCountDandE(letterCountArray) (
   letterCountArray filter $.letter == "D" or $.letter == "E" map {
   count:  $.count}.count reduce ($$ + $)
)
---
result: payload.letterCountArrayfilter
           $.letter == "A" or $.letter == "B" or $.letter == "C" or $.letter == "D" map
    using (countOfDandE = getCountDandE(payload.letterCountArray)){

(letterA: {
   Letter: $.letter,
   Count: $.count
}) when $.letter == "A",

(letterB: {
   Letter: $.letter,
   Count: $.count
}) when $.letter == "B",

(letterC: {
   Letter: $.letter,
   Count: $.count
}) when $.letter == "C",

(letterDandE: {
   Letter: "D+E",
   Count: countOfDandE
}) when $.letter == "D"

}

which will now give the result:

{
  "result": [
   {
      "letterA": {
        "Letter": "A",
        "Count": 5
      }
    },
    {
      "letterB": {
        "Letter": "B",
        "Count": 3
      }
    },
    {
      "letterC": {
        "Letter": "C",
        "Count": 6
      }
    },
    {
      "letterDandE": {
        "Letter": "D+E",
        "Count": 12
      }
    }
  ]
}

As you can see the using operator is a powerful feature but remember, as Stan Lee says, "with great power comes great responsibility".

Reduce allows us to iterate an array to accumulate a result. There are a few array operators like filter and map that do similar functions. You can use reduce to filter an array or map an array because you can reduce an array into another array but that wouldn't be best practice. Ideally you want to use reduce to produce a single result.

Here are some examples of using reduce with an array of numbers.

%dw 2.0 output application/json 
--- 
{     
   "sum reduce short form" : [0, 1, 2, 3, 4, 5] reduce ($$ + $),     
   "sum long form" : [0, 1, 2, 3, 4, 5] reduce ((val, acc) -> acc + val),     
   "sum sum operator" : sum ([0, 1, 2, 3, 4, 5]),     
   "sum start" : [0, 1, 2, 3, 4, 5] reduce ((val, acc=2) -> acc + val),     
   "sum sum operator with start value" : 2 + sum ([0, 1, 2, 3, 4, 5]) 
} 

Which will produce these results:

{   
   "sum reduce short form": 15,   
   "sum long form": 15,   
   "sum sum operator": 15,   
   "sum start": 17,   
   "sum sum operator with start value": 17 
}

If you have a shop with many DataWeave developers (more than three) I'd go with the short form of reduce otherwise the long form is more intuitive to a non DataWeave developer trying to maintain the code.

Using the long form, "acc" is the accumulator and "val" is the value of each item in the array. When the values in your array are numbers, the first value will be zero. If your values are strings then the first value will be "". You can start with a value other than 0 by setting acc=2.

From the examples above, I would recommend using the sum operator instead of reduce because it is clearer what you are trying to do in the code.

Reduce can also be used to process strings, by using the ++ operator. Below are some interesting examples that show how this can be done. Once again it is better practice to use the string operator joinBy which makes the intention of your code clearer.

%dw 2.0 output application/json 
var sentence ="How are you doing?" 
--- 
{     
   "string created with reduce":     
   ["H", "e", "l", "l", "o"] reduce($$ ++ $),     
   "string created with joinBy":     
   ["H", "e", "l", "l", "o"] joinBy(""),     
   "words created with splitBy" :     
   sentence splitBy(" "),     
   "sentence processed with splitBy filter and reduce" :     
   (sentence splitBy(" ")) filter $ != "are" reduce($$ ++ " " ++ $),     
   "sentence processed with splitBy filter and joinBy" :     
   (sentence splitBy(" ")) filter $ != "are" joinBy(" ") 
} 

which produces the following results:

{   
   "string created with reduce": "Hello",   
   "string created with joinBy": "Hello",   
   "words created with splitBy": 
    [     "How",     "are",     "you",     "doing?"   ],          
   "sentence processed with splitBy filter and reduce": 
    "How you doing?",   
   "sentence processed with splitBy filter and joinBy": "How you doing?" 
}

Reduce can be useful when you need to apply a function to every item in the array, for example, applying a tax rate with rounding to each value, to ensure you get the correct rounding for your total result. I'll be writing an article about the more advanced uses of reduce shortly.

Thanks for reading.