Azure Bicep lambda expressions

If you have a C# (or almost any other language) development background, this will be familiar to you. Recently, the Bicep team introduced lambda expressions. With the introduction of lambda expressions in Azure Bicep, you can manipulate arrays. In Bicep, the operator declaration is =>. The new functions that support lambda’s and are implemented:

• filter()
• map()
• reduce()
• sort()

The lambda expression format is as follows:

<lambda variable> => <expression>

To use Azure Bicep lambdas, the version requirement is v0.10.61 or higher.

Bicep Example

To illustrate how these lambda expressions work, I created an example array in Bicep. In this Bicep file, an array has been declared as a variable with information about groceries:

If you want to run the examples from the blog post, you can run the following command:

az deployment group create --resource-group <rg> --template-file <file> --query "properties.outputs"

filter()

Let’s take a looks at the first function: filter(). The filter function filters an array based on a given criteria. For example, only show the products priced higher than 4 or where the characteristics of the product contain a specific condition.

The filter method expects two parameters, namely: filter(inputArray, lambda expression). The first parameter is the array that has to be filtered, and the second parameter is the lambda expression that is applied to each input array element.

Let’s see filter in action:

Filter every object that has a lower productPrice than 4:

Result:

Filter every object that does not have the characteristic ‘Bio’:

Result:

map()

The map() function applies a function to the element selected from the array. 

The map function expects two parameters, namely: map(inputArray, lamba expression).

In the example, there is an array containing multiple objects, which represent a product in the grocery store. If you only want to use the productName you can use map() to select the property productName and set this as an output or variable:

Result

Use map and create a sentence with string interpolation:

Result

Use map and create an object and added productNumber and discountedPrice:

Result

The non-lambda way

It’s possible to achieve the same using foreach loops, but when you want to create an object, it will be easier to use map. The foreach loop would look like this:

var varGetProductNameUsingLoop = [for item in varGroceryStore: item.productName]

reduce()

The reduce() function can be seen as an accumulator. With reduce() you can generate a single value from properties in an array. In the given example, you can use the productPrice to calculate the total price of every product in the grocery store.

The reduce function expects three parameters, namely: reduce(inputArray, initialValue, lamba expression).

Let’s see reduce() in action.

Use reduce to accumulate product prices:

First, use map() to get the productPrice, after that use reduce() to accumulate the productPrice values. The 0 means the starting value to accumulate from. The reduce function loops through the values and accumulates the currentValue and previousValue:

• First loop: currentValue (5) + previousValue (0)
• Second loop: currentValue (2) + previousValue (5)
• Third Loop and last loop: currentValue (4) + previousValue (7)
• Outcome: 11

Result

sort()

The sort() function sorts an array based on a given criteria. In the given example, the array of groceries can be sorted using the productPrice from low to high or productNames can be sorted alphabetically. The sort function expects two parameters, namely: sort(inputArray, lamba expression).

Let’s see sort() in action.

Sort the array with the productPrices from low to high:

Result

Sort the productNames alphabetically:

Result

Conclusion

This is how lambda’s can be used in Azure Bicep. I think lambda’s are a great addition to the Azure Bicep function suite because of the ability to manipulate an array and use these manipulations in outputs or variables.