Naresha

Consider the following closure sum and it's use in inject method. def numbers = [1, 2, 3, 4, 5, 6, 7] def sum = { number1, number2 -> number1 + number2 } println numbers.inject(0, sum) // 28 If you are not familiar with Groovy closures, this post has the details. In

One of the common tasks in programming is to generate a summary from a collection of data. To make the concept easy for understanding, consider the following list of numbers. def numbers = [1, 2, 3, 4, 5, 6, 7] Suppose we want to find the sum of number in the

In my previous post, I wrote about map transformation. Similarly, another common operation is filtering values from a collection that satisfy a condition. We refer to the condition as a predicate. Consider the following list of numbers. def numbers = [1, 2, 3, 4, 5, 6, 7] Let's write

Functional programming languages provide a map higher order function, which produces a new collection by applying the specified function on each element of the collection on which the map operation is invoked. Groovy uses collect instead of map. Consider the following list of numbers. def numbers = [1, 2, 3, 4]

Suppose you have a computation heavy function. def computeHeavyFunction(def number) { println "computeHeavyFunction called with $number" number + 1 } println computeHeavyFunction(1) println computeHeavyFunction(2) println computeHeavyFunction(1) In the absence of println statement, this function would have been pure. I have added the print statement just for the

Let us create a function that computes the factorial of a number using recursion. def factorial(def number) { if(number == 0){ 1 } else{ number * factorial(number - 1) } } println factorial(1) // 1 println factorial(3) // 6 println factorial(10) // 3628800 What would happen if we invoke factorial function with 17

Consider the following list of numbers. def numbers = [1, 2, 3, 4, 5] Iteration Let's calculate the sum of numbers. First let us approach solution using imperative method def computeSumImperative(List numbers) { def sum = 0 def iterator = numbers.iterator() while(iterator.hasNext()){ sum += iterator.next() } sum } println computeSumImperative(

In our drive to write Groovy code in functional style, we write pure functions as much as possible. Since mutation is not allowed in pure functions, immutable data become an important foundation. If you are not familiar with pre functions, this article provides the necessary details. Immutable Collections Let us

Functional programming and pure functions go hand in hand. When we program in functional style, it is recommended to write pure functions as much as possible. So what are pure functions? A pure function is one which * Does not produce any side effects and * Does not depend on any side

Consider the following closures. def increment = { number -> number + 1 } def square = { number -> number * number } println increment(2) // 3 println square(2) // 4 If you are not familiar with closures, this article provides the necessary details. Now suppose you want to calculate the square of a number