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

One of the design techniques used in functional programming is to create a generic functions and derive special functions from the generic ones by fixing some of the arguments. To understand this consider the following use-case. We want to be able to double, triple and quadruple numbers. We can write

Lets create a closure which adds two numbers. def add = { number1, number2 -> number1 + number2 } If you are not familiar with closures, this article has the necessary details. Let's create a function which accepts this closure and invokes it by passing two numbers. def perform(def operation)

From functions to closures Consider the following function. def greet() { println "Hello" } You can invoke the greet function in the following way greet() // prints "Hello" Unlike variables/ values, one can neither pass a function as an argument to another function nor return a function from another

Abstract Groovy is a dynamic language on Java platform. Groovy provides extensive support for working with collection, with native support for list and map literals.In this article, I will explore the options for working with collections effectively. We will explore various collection types, internal iterators, map reduce methods, method

Abstract Groovy is a dynamic language on Java platform. Groovy provides extensive support for working with collection, with native support for list and map literals.In this article, I will explore the options for working with collections effectively. We will explore various collection types, internal iterators, map reduce methods, method