functional programming with groovy
DESCRIPTION
My talk about Functional Programming with Groovy at Greach Greach http://greach.es/ the Groovy spanish conf Date: 04-11-2011TRANSCRIPT
Functional Programmingwith Groovλ
Working at OSOCO
Small but outstanding software development shop
Groovy and Grails hackers
on EC2 cloud nine
TDD mantra singers
Quality preachers
(define (factorial n) (if (= n 1) 1 (* n (factorial (- n 1)))))
LISt Processing
( (factorial ) ( ( ) ( (factorial ( )))))
Lots of Insipid Stupid Parentheses
Code Complete
The Pragmatic Programmer
Structure and Interpretation of Computer Programs
A language that doesn't affect the way you think
about programming, is not worth knowing
Alan Perlis
Functional Programming
Function
Functional Programming
Avoiding Mutable State Side-Effect-Free Functions Referential Transparency First-Class Citizens Higher-Order Functions Lambdas and Closures Lazy Evaluation Recursion
λλ
λλ
λλ
λλ
Why Functional Programming?
Referential transparency Unit testing Debbuging Parallelization Modularity and composition Increases the quality of code Abstractions
λλ
λλ
λλ
λ
OOP vs. FP
Imperative vs. Declarative
Imperative: how to achieve our goal Take the next customer from a list. If the customer lives in Spain, show their details. If there are more customers in the list, go to the beginning
Declarative: what we want to achieve Show customer details of every customer living in Spain
Imperative vs. Declarative
Functional programming is like describing your problem to a mathematician.
Imperative programming is like giving instructions to an idiot.
arcus, #scheme on Freenode
Functional Programmingwith Groovy?
is an imperative language,
but we still can apply functional principles
It's basically a programmer's choice
Immutability
Simple Immutable objects can only be in exactly one state, the state in which it was created
Always consistent Less prone to errors and more secure
Immutable objects can be shared freely Freedom to cache
Inherently thread-safe
Immutability
NO: (even being a name rebind and not a real update)
book = 'Fooled by Randomness'book = "$book - Nassim Taleb"book = "$book (2001)"assert 'Fooled by Randomness - Nassim Taleb (2001)' == book
YES:book = 'Fooled by Randomness'bookWithAuthor = "$book - Nassim Taleb"completeBook = "$bookWithAuthor (2001)"assert 'Fooled by Randomness - Nassim Taleb (2001)' == completeBook
Immutability
NO:years = [2001, 2002]years << 2003years += [2004, 2005]assert [2001, 2002, 2003, 2004, 2005] == years
YES:years = [2001, 2002]allYears = years + 2003 + [2004, 2005]assert [2001, 2002, 2003, 2004, 2005] == allYears
Immutability
def list = ['Gr', 'vy']
NO:
list.addAll 1, 'oo'assert list == ['Gr', 'oo', 'vy']
YES:
assert list.plus(1, 'oo') == ['Gr', 'oo', 'vy']assert list == ['Gr', 'vy']
Immutability
def list = [1, 2, 2, 3]
NO:
list.removeAll 2assert list == [1, 3]
YES:
assert list.minus(2) == [1, 3]assert list == [1, 2, 2, 3]
Immutability
def list = ['Scala', 'Groovy', 'Java']
NO:
sortedList = list.sort()assert sortedList == ['Groovy', 'Java', 'Scala']assert list == ['Groovy', 'Java', 'Scala']
YES:
sortedList = list.sort(false)assert sortedList == ['Groovy', 'Java', 'Scala']assert list == ['Scala', 'Groovy', 'Java']
Immutability
def list = ['Java', 'Groovy', 'Java']
NO:
uniqueList = list.unique()assert uniqueList == ['Java', 'Groovy']assert list == ['Java', 'Groovy']
YES:
uniqueList = list.unique(false)assert uniqueList == ['Java', 'Groovy']assert list == ['Java', 'Groovy', 'Java']
Immutability
def list = ['Java', 'Groovy']
NO:
reverseList = list.reverse(true)assert reverseList == ['Groovy', 'Java']assert list == ['Groovy', 'Java']
YES:
reverseList = list.reverse()assert reverseList == ['Groovy', 'Java']assert list == ['Java', 'Groovy']
Immutability Collection
def list = ['Groovy', 'Java'].asImmutable()assert 'Groovy' == list.first()
try { list.add 'Scala' // Cannot add item} catch (e) { assert e instanceof UnsupportedOperationException}
try { list.remove 'Java' // Cannot remove item} catch (e) { assert e instanceof UnsupportedOperationException}
Immutability Class
@Immutable class Coordinates { Double latitude, longitude }
def c1 = new Coordinates(latitude: 48.824068, longitude: 2.531733)
def c2 = new Coordinates(48.824068, 2.531733)
assert c1 == c2
Higher-Order Functions
First-Class Citizen Can be stored in variables Can be passed as function parameter Can be returned from functions
Higher-Order Functions (First-Class Functions)
Functions that take other functions as arguments or return them as results
Closures
def closure = { 'Hello world!' } assert closure() == 'Hello world!'
def sum = { a, b -> a + b } assert sum(2,3) == 5
def square = { it * it } assert square(9) == 81
final BASE = 1000 def salary = { variable -> BASE + variable } assert salary(500) == 1500
Turn Methods into Closures
def salary(variable) { final BASE = 1000 BASE + variable } assert salary(500) == 1500
def salaryClosure = this.&salary assert salaryClosure(500) == 1500
Closures Composition
def minutesToSeconds = { it * 60 }def hoursToMinutes = { it * 60 }def daysToHours = { it * 24 } def hoursToSeconds = minutesToSeconds << hoursToMinutesdef daysToSeconds = hoursToSeconds << daysToHours
assert daysToSeconds(1) == 86400
Closures Composition
def upper = { it.toUpperCase() }def firstLetter = { it.charAt(0) }
def words = ["Don't", "Repeat", "Yourself"]def acronym = words.collect(firstLetter >> upper).join()
assert acronym == 'DRY'
Currying
given: ƒ: (X x Y) -> Z
then: curry(ƒ): X -> (Y -> Z)
Takes a function with a particularnumber of parameters and returns afunction with some of the parametervalues fixed, creating a new function
Currying
def modulus = { mod, num -> num % mod } assert modulus(2, 5) == 1 assert modulus(3, 5) == 2
def mod2 = modulus.curry(2) assert mod2(5) == 1 def mod3 = modulus.curry(3) assert mod3(5) == 2
Currying
def bill = { amount, currency -> "$amount $currency" } assert bill(1000, '$') == '1000 $' assert bill(1000, '€') == '1000 €'
def billInDollars = bill.rcurry('$') assert billInDollars(1000) == '1000 $'
def billInEuros = bill.rcurry('€') assert billInEuros(1000) == '1000 €'
Currying
def joinWithSeparator = { one, sep, two -> one + sep + two }
def joinWithAmpersand = joinWithSeparator.ncurry(1, '&')
assert joinWithAmpersand('a', 'b') == 'a&b'
Classic Operations on Functional Data Types
list filter
map
fold
Classic Operations on Functional Data Types
list findAll
collect
inject
Classic Operations on Functional Data Types
list any
sort
sum
every
min
findAll()NO:
def result = [][1, 2, 3, 4].each { if (it > 2) { result << it }}assert result == [3, 4]
YES:
assert [1, 2, 3, 4].findAll{ it > 2 } == [3, 4]
collect()NO:
def result = [][1, 2, 3].each { result << it * 2}assert result == [2, 4, 6]
YES:
assert [1, 2, 3].collect{ it * 2 } == [2, 4, 6]
inject()NO:
def total = 0[1, 2, 3].each { total += it}assert total == 6
YES:
def total = [1, 2, 3].inject(0) { acc, n -> acc + n}assert total == 6
find()NO:
def resulttry { [1, 2, 3].each { if (it > 1) { result = it throw new Exception() // monstrous } }} catch(exception) { }assert result == 2
YES:
assert [1, 2, 3].find{ it > 1 } == 2
max() @TupleConstructor // import groovy.transform.* class Person { String name Integer age }
def person1 = new Person('Arturo', 26) def person2 = new Person('Luis', 61) def person3 = new Person('Laura', 19) def family = [] << person1 << person2 << person3
assert family.max{ it.age }.age == 61 assert family.collect{ it.age }.max() == 61 assert family*.age.max() == 61
Refactoring def exists = false family.each { person -> if (person.age > 60) { exists = true } } assert exists == true
def exists = family.inject(false) { found, person -> if (person.age > 60) { found = true } return found } assert exists == true
assert family.any{ it.age > 60 } == true
@TupleConstructor // import groovy.transform.* class Person { String name String lastname Integer age }
def rafa = new Person('Rafael', 'Luque', 36) def marcin = new Person('Marcin', 'Gryszko', 34) def arturo = new Person('Arturo', 'Herrero', 26) def osokers = [] << rafa << marcin << arturo << rafa assert osokers.unique(false) .findAll{ it.age > 30} .sort{ it.lastname } == [marcin, rafa]
assert osokers == [rafa, marcin, arturo, rafa]
Combinator Functions
Combinator Functions // Procedural style def count = 0 for (i in (1 .. 1000)) { if (i % 2) { count += ("$i".size()) } } assert count == 1445
// Functional style def count = (1 .. 1000).findAll{ it % 2 } .collect{ "$it" } .inject(0) { sum, num -> sum + num.size() } assert count == 1445
Lazy Evaluation
Only does as much work as necessary Delays the evaluation of the expression until it's needed
CPU efficient The value is not calculated or assigned until the value is requested
Manage potentially infinite data structures Only a manageable subset of the data will actually be used
Lazy Evaluation
class Person { @Lazy String name = 'Arturo' } def person = new Person() assert !(person.dump().contains('Arturo'))
assert person.name.size() == 6 assert person.dump().contains('Arturo')
Lazy Evaluation
class Get { String url @Lazy URL urlObj = { url?.toURL() }() @Lazy(soft=true) String text = urlObj?.text }
def get = new Get(url: 'http://arturoherrero.com') assert get.url == 'http://arturoherrero.com' assert get.dump().contains('text=null') assert get.dump().contains('urlObj=null')
assert get.urlObj.protocol == 'http' assert get.urlObj.host == 'arturoherrero.com' assert get.text.contains('Arturo Herrero')
Lazy Evaluation
groovy.sql.DataSet.DataSet groovy.util.XmlSlurper
@Singleton(lazy=true) class Util { Integer count(text) { text.size() } } assert 6 == Util.instance.count('Arturo')
Infinite structures
class LazyList { ...}
def naturalnumbers = integers(1)assert '1 2 3 4 5 6' == naturalnumbers.take(6).join(' ')
def evennumbers = naturalnumbers.filter{ it % 2 == 0 }assert '2 4 6 8 10 12' == evennumbers.take(6).join(' ')
Infinite structures
@Grab('org.functionaljava:functionaljava:3.0')import fj.data.Stream
Stream.metaClass.filter = { Closure c -> delegate.filter(c as fj.F) }
Stream.metaClass.asList = { delegate.toCollection().asList() }
def evens = Stream.range(1).filter{ it % 2 == 0 }assert [2, 4, 6, 8, 10, 12] == evens.take(6).asList()
Recursive factorial(6) 6 * factorial(5) 6 * (5 * factorial(4)) 6 * (5 * (4 * factorial(3))) 6 * (5 * (4 * (3 * factorial(2)))) 6 * (5 * (4 * (3 * (2 * factorial(1))))) 6 * (5 * (4 * (3 * (2 * 1)))) 6 * (5 * (4 * (3 * 2))) 6 * (5 * (4 * 6)) 6 * (5 * 24) 6 * 120 720
Recursive factorial(6) 6 * factorial(5) 6 * (5 * factorial(4)) 6 * (5 * (4 * factorial(3))) 6 * (5 * (4 * (3 * factorial(2)))) 6 * (5 * (4 * (3 * (2 * factorial(1))))) 6 * (5 * (4 * (3 * (2 * 1)))) 6 * (5 * (4 * (3 * 2))) 6 * (5 * (4 * 6)) 6 * (5 * 24) 6 * 120 720
Tail-Recursive factorial(6, 1) factorial(5, 6) factorial(4, 30) factorial(3, 120) factorial(2, 360) factorial(1, 720)
Tail-Recursive factorial(6, 1) factorial(5, 6) factorial(4, 30) factorial(3, 120) factorial(2, 360) factorial(1, 720)
Tail Call Optimization
3 techniques:
The compiler transform the recursion into a loop
Let the JVM recognize the recursion and eliminate it
Transform the recursion into iterative by hand
λλ
λ
Tail Call Optimization
3 techniques:
The compiler transform the recursion into a loop
Let the JVM recognize the recursion and eliminate it
Transform the recursion into iterative by hand
λλ
λ
really?
Tail Call Optimization
def factorial
factorial = { n -> n == 1 ? 1 : n * factorial(n - 1) }
factorial(1000)
Tail Call Optimization
def factorial
factorial = { n -> n == 1 ? 1 : n * factorial(n - 1) }
factorial(1000)
Stack Overflow
Tail Call Optimization
def factorial
factorial = { n, BigInteger acc = 1 -> n == 1 ? acc : factorial(n - 1, n * acc) }
factorial(1000)
Tail Call Optimization
def factorial
factorial = { n, BigInteger acc = 1 -> n == 1 ? acc : factorial(n - 1, n * acc) }
factorial(1000)
Stack Overflow
Tail Call Optimization
def factorial
factorial = { n, BigInteger acc = 1 -> n == 1 ? acc : factorial.trampoline(n - 1, n * acc) }.trampoline()
factorial(1000)
Trampolining
def even, odd
even = { x -> x == 0 ? true : odd.trampoline(x - 1) }.trampoline()
odd = { x -> x == 0 ? false : even.trampoline(x - 1) }.trampoline()
assert even(1000) == true
Memoization
def fibonacci
fibonacci = { n -> n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2) }
fibonacci(35) // 9.935 seconds
Memoization
def fibonacci
fibonacci = { n -> n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2) }.memoize()
fibonacci(35) // 0.002 seconds
def plus = { a, b -> sleep 1000; a + b }.memoize()
assert plus(1, 2) == 3 // after 1000ms assert plus(1, 2) == 3 // return immediately assert plus(2, 2) == 4 // after 1000ms assert plus(2, 2) == 4 // return immediately def plusAtLeast = { ... }.memoizeAtLeast(10) def plusAtMost = { ... }.memoizeAtMost(10) def plusBetween = { ... }.memoizeBetween(10, 20)
Memoization
“Functional” is more a way of thinkingthan a tool set
Neal Ford
Be a craftsman
Thank you! @ArturoHerrero
Join us at OSOCO