Functional Lists in Groovy

Lately I’m reading books on functional programming languages like Clojure and Erlang. There is a book for Erlang that covers all aspect of the language Programming Erlang. There is also one book(in spanish) very good for Erlang and is free from bosqueviejo. And for Clojure there are many like The Joy of Clojure or Functional Programming for the Object-Oriented Programmer.

What I’ve learned in these books is to think of another way to abstract problems and break them into reusable functions (also aspects such as concurrency, immutability and recursion).

Groovy has much functional style , in fact , the closures for me is a clear example:

def multiplyBy2 = {element -> element * 2 } /* 'collect', is the function to iterate list and return the result apply to the closure */ assert [1,2,3].collect{ it * 2 } == [2,4,6] assert [1,2,3].collect{ multiplyBy2(it) } == [2,4,6]

The functions that I will show below, I will add them to the class List dynamically by the metaclass. I think it’s better example that only show the functions , because then can reuse the functions in other parts of project.

For example, I will mimic the function map/2 from Erlang and I will add to the Groovy List class.

Map

Is a function that takes a function F and list L as arguments and returns the new list that is obtained by applying F to each of the elements in L.

/* Closure with 2 arguments: -closure_F is the function F -list_L is list L */ def map = { list_L , closure_F -> // Delegate is the elment to actue over delegate.collect(list_L) { element -> closure_F(element) } } // Add to metaClass of List dynamically with name "map" List.metaClass.map = map def list = [1,2,3,4] def newList = [] list.map( newList ){ it * 2 } assert newList == [2,4,6,8] assert list == [1,2,3,4]

I’ve done a bit tricky, because in reality the “map” function does not apply on a list already created, but I did so to show how to add a method to the List class dynamically. But I made it more functional as possible, without modifying the original list and returning a new list( it is not inmutable, in Groovy to make a List inmutable call -> asInmutable() )

Be careful with add methods by metaClass , because if a method already exists with the same name it will be overwritten.

Let’s do another example, I’ll imitate the function pluck of Underscore.js .

Pluck

This function is the common use-case for map : extracting a list of property values.

/* One argument: -propertyName */ def pluck = { propertyName -> // Collect results filter coincidence by propertyName delegate.collect { element -> element."$propertyName" } } // Add "pluck" to metaClass of List List.metaClass.pluck = pluck def users = [[name:"Joe",age:32],[name:'Jhon',age:20],[name:'Mary',age:25]] assert users.pluck("name") == ["Joe","Jhon","Mary"]

As we see it is very easy to add functions to the Groovy List class, that are useful and / or we use a lot. In addition to obtain clean code, we can combine them to make still more powerful.

Note: If you use Grails these functions can be added dynamically with the Bootstrap.groovy ; so these functions can be used in all the classes of the project.

Functional Lists in Groovy

Map

Pluck

Comments