An Introduction to Functional Programming at the Jozi Java User Group

Introduction Deﬁnition Function Recap Common Idioms Imperative Comparison Challenges! Industry Use Now what?
An Introduction to Functional Programming
Andreas Pauley – @apauley
Jozi JUG
July 28, 2014

@lambdaluminary
We meet once a month, on the second Monday of the month.
http://www.meetup.com/lambda-luminaries/

Jemstep
Retirement portfolio analysis in Scala.
http://www.jemstep.com/

Who likes FP?
“ And that’s why I think functional
programming is a natural successor to
object-oriented programming. ”
— Dave Thomas, Pragmatic Programmers [2]
“ Without understanding functional
programming, you can’t invent MapReduce ”
— Joel Spolsky [3]
“ ...it’s almost certainly true that functional
programming is the next big thing. ”
— Uncle Bob Martin [4]

“ No matter what language you work
in, programming in a functional style
provides beneﬁts. You should do it
whenever it is convenient, and you
should think hard about the decision
when it isn’t convenient. ”
— John Carmack, ID Software [5]

But what exactly is
“Functional Programming”?

A simple programming example
Say I give you an array of integers, and I want every
one of them doubled.
How would you write it?

I have this:
[1,3,6]
I want this:
[2,6,12]

public static void doubleAll(int[] numbers) {
for (int i=0; i < numbers.length; i++) {
numbers[i] = numbers[i] * 2;
}
}

Sorry, I forgot to mention that you cannot do
in-place mutation on the list of numbers I give you.
Please try again.

Our ﬁrst try had a void return type:
public static void doubleAll(int[] numbers) {
numbers[i] = numbers[i] * 2;
}
}
Now we have to return a result:
public static int[] doubleAll(int[] numbers) {
int[] nums2 = new int[numbers.length];
nums2[i] = numbers[i] * 2;
}
return nums2;
}

Looking much better, but you can’t mutate any
collection, appending to the new array won’t work.
Also, you can’t vary your variables (i++).
Please try again.

???
public static int[] doubleAll(int[] numbers) {
int[] nums2 = new int[numbers.length];
nums2[i] = numbers[i] * 2;
}
return nums2;
}

Let’s try giving a deﬁnition of
Functional Programming

Functional Programming, noun:
Functional Programming is a
list of things you CAN’T do.
[10]

You can’t vary your variables
1> X = 42.
42
2> X = X + 1.
** exception error:
no match of right hand
side value 43

No while/for loops. Sorry :-(
int i;
for (i=1; i<=3; i++) {
System.out.println(i);
}

You can’t mutate/change your data structures
Python
>>> list1 = [1,2,3]
>>> list2 = list1
>>> print list1.reverse()
None
>>> list1
[3, 2, 1]
>>> list2
[3, 2, 1]
Haskell
> let list1 = [1,2,3]
> let list2 = list1
> reverse(list1)
[3,2,1]
> list1
[1,2,3]
> list2
[1,2,3]

You can’t have any side e↵ects

Are you kidding me?
How can anyone program like this???

GOTO 10
This sounds like
“You can’t have GOTO statements”
See Hughes and Dijkstra [1, 6]

It’s not about what we cannot
do.

We need a better deﬁnition of
Functional Programming.

Programming Paradigms
(Very Simpliﬁed)
Imperative Declarative

Functional Programming, noun:
“ Functional programming is so called because a
program consists entirely of functions. ”
— John Hughes, Why Functional Programming Matters [1, p. 1]

OK... so what exactly is a function?

An example function
f(x) = 2x2 2x + 3
1 1 2 3
4
6
8
10
12
14
x
y

Variables in functions
f(x) = 2x2 2x + 3
When we evaluate the function:
f(2) = 8 4 + 3 = 7
• The value of x will not change inside the function body.

f(x) = 2x2 2x + 3
f(2) = 8 4 + 3 = 7
• Same input, same output. Every time. (Referential
Transparency)

f(x) = 2x2 2x + 3
f(2) = 8 4 + 3 = 7
Transparency)
• We can call f multiple times without any side e↵ects.

f(x) = 2x2 2x + 3
f(2) = 8 4 + 3 = 7
Transparency)
• We can call f multiple times without any side e↵ects.
• We don’t have to recalculate f(2), we can replace any
occurrence of f(2) with 7.

Varying variables does not make sense
x = x + 1
x x = 1
0 = 1
) x 6= x + 1

Values are functions
Constant values are just functions with no input parameters
x = 42
Python function deﬁnition:
def x():
return 42
Haskell function deﬁnition:
x = 42

Functions can be composed
h(x) = (f g)(x) = f(g(x))
or
h = f g

Higher-order Functions
Functions can take functions as input.
Functions can return functions as the result.
h(f, g, x) = f(x) + g(2)

The derivative of f(x) returns another function.
f(x) = 2x2
2x + 3
d
dxf(x) = 4x 2
1 1 2 3
5
10
15
x
y

A functional program consists entirely of functions
def main():
time = datetime.now()
args = sys.argv[1:]
print outputString(time, args)
def outputString(time, args):
return str(time) + " " + joinArgs(args)
def joinArgs(args):
return "-".join(args)
$ ./justfunctions.py Hello from Python
2014-02-15 10:36:42.062697 Hello-from-Python

A functional program consists entirely of functions
main :: IO()
main = do
time <- getCurrentTime
args <- getArgs
putStrLn (outputString time args)
outputString :: UTCTime -> [String] -> String
outputString time args =
show(time) ++ " " ++ joinArgs(args)
joinArgs :: [String] -> String
joinArgs = intercalate "-"
$ ./justfunctions Hello from Haskell
2014-02-15 08:36:50.822728 UTC Hello-from-Haskell

Some Haskell Syntax
Python:
def outputString(time, args):
return str(time) + " " + joinArgs(args)
Haskell:
outputString :: UTCTime -> [String] -> String
outputString time args =
show(time) ++ " " ++ joinArgs(args)

Recursive function: Haskell
doubleAll :: [Int] -> [Int]
doubleAll [] = []
doubleAll (x:xs) = x*2 : doubleAll xs
Example use in the interactive interpreter:
Prelude Main> doubleAll [8,2,3]
[16,4,6]

Recursive function expanded
doubleAll [] = []
doubleAll [8,2,3]
16 : (doubleAll [2,3])
16 : 4 : (doubleAll [3])
16 : 4 : 6 : (doubleAll [])
16 : 4 : 6 : []
16 : 4 : [6]
16 : [4,6]
[16,4,6]

Recursive function: Python
def doubleAll(numbers):
if numbers == []:
return []
else:
first = numbers[0]
rest = numbers[1:]
return [first * 2] + doubleAll(rest)
Example use in the interactive interpreter:
>>> doubleAll([8,2,3])
[16, 4, 6]

Pattern Matching: Haskell
doubleAll :: [Int] -> [Int]
doubleAll [] = []

3 Basic List Operations
Map Convert each element of a list into some other value.

Filter Get a subset of a list based on some condition.

Filter Get a subset of a list based on some condition.
Fold Reduce a list of items to a single value.

Map
Apply a function to each element of a list, and you get a new list.
a1 a2 a3 ... an
b1 b2 b3
... bn
f(a1) f(an)

Map
doubleAll :: Num a => [a] -> [a]
doubleAll = map (*2)
8 2 3
16 4 6
⇤2 ⇤2 ⇤2

Account Data
data Bank = ABSA | Capitec | FNB | Nedbank | SBSA
data Account = Account {bank :: Bank,
accNum :: String,
owner :: String,
balance :: Amount}

Account Data
[Account {accNum="4076814233",
owner="J. Doe",
balance=(Amount 123000.23),
bank=ABSA},
Account {accNum="6868773585",
owner="J. Black",
bank=FNB},
owner="A. Kay",
balance=(Amount 100),
bank=ABSA},
owner="S. Jones",
bank=FNB}]

Map
Map on account data:
balances :: [Account] -> [Amount]
balances accounts = map balance accounts
acc1 acc2 acc3 acc4 acc5
bal1 bal2 bal3 bal4 bal5
balance(acc1) balance(acc5)

Filter
acc1 acc2 acc3 acc4 acc5
acc1 acc3 acc5
in? in? in? in? in?

Filter
Filter on account data:
topAccounts :: [Account] -> [Account]
topAccounts accounts = filter isRich accounts
isRich :: Account -> Bool
isRich acc = balance acc >= (Amount 1000000)
Output:
*Main> topAccounts accounts
[FNB 6868773585 (J. Black) R5782347.99,
FNB 6584539813 (S. Jones) R2937361.45]

Fold/Reduce/Inject
foldl (+) 0 [8,2,3]
13
0 8 2 3
8 2 3
10 3
13

Fold/Reduce/Inject
balanceSum :: [Account] -> Amount
balanceSum accounts = foldl (+) 0 (balances accounts)
0 bal1 bal2 bal3
sum bal2 bal3
sum bal3
sum

Function Composition
balanceSum :: [Account] -> Amount
balanceSum accounts = foldl (+) 0 (balances accounts)
0 bal1 bal2 bal3
sum bal2 bal3
sum bal3
sum
s2 :: [Account] -> Amount
s2 = balances |> (foldl(+)0)
h(x) = (f g)(x) = f(g(x))
h = f g
s3 = f1 balances
s3 :: [Account] -> Amount
s3 = (foldl(+)0) . balances

balancesPerBank
foldl insertBalance Map.empty accounts
{} acc1 acc2 acc3
map acc2 acc3
map acc3
map

Fold
type BankMap = Map Bank Amount
balancesPerBank :: [Account] -> BankMap
balancesPerBank = foldl insertBalance Map.empty
Output:
*Main> balancesPerBank accounts
fromList [(ABSA,R123100.23),(FNB,R8719709.44)]

Fold
type BankMap = Map Bank Amount
balancesPerBank :: [Account] -> BankMap
balancesPerBank = foldl insertBalance Map.empty
insertBalance :: BankMap -> Account -> BankMap
insertBalance bankmap account =
Map.insert key value bankmap
where key = bank account
value = addBalance bankmap account
addBalance :: BankMap -> Account -> Amount
addBalance bankmap account =
case (Map.lookup (bank account) bankmap) of
Nothing -> balance account
Just bal -> (balance account) + bal

In imperative programming:
• Your variables can vary any time!

• You have to use locks to be thread-safe!

• You have to write your own loops for the most basic list
operations!

operations!
• Your data structures are mutable!

operations!
• You have to defensively make copies of data to prevent bugs!

operations!
• You have to defensively check for null values!

operations!
• You have to think about implicit state! (this, self)

operations!
• You have to think about implicit state! (this, self)
• Code is generally riddled with side e↵ects!

Unit tests
Start writing the unit tests for
your existing code in a
functional programming
language

Join the anti-for campaign
Less loops, more
map/ﬁlter/fold
http://weblogs.asp.net/podwysocki/archive/2009/06/26/
the-anti-for-campaign.aspx

Treat side e↵ects as a ﬁrst-class concern

Learn a functional language
“ A language that doesn’t a↵ect the way you think
about programming, is not worth knowing. ”
— Alan Perlis[8]

Disclaim your inheritance
Write non-trivial code without
using objects and inheritance.
Get re-usability with higher-order functions.
Try to minimise moving parts instead of
encapsulating moving parts. [7]

Join our group
@lambdaluminary
We meet once a month, on the second Monday of the month.
http://www.meetup.com/lambda-luminaries/

Get out of your comfort zone
Functional Programming is unfamiliar territory for
most.
“ If you want everything to be familiar you will
never learn anything new. ”
— Rich Hickey, author of Clojure[9]

Companies In South Africa
Jemstep, Sandton Using Scala for Fund Analysis
Allan Gray, Cape Town Using Scala for backend logic and system
integration.
Yuppiechef, Cape Town Using Clojure for their Warehouse
Management System.
Cognician, Cape Town Using Clojure to create coaching/learning
modules.
Eldo Energy, Johannesburg Using Clojure for automated meter
reading and intelligent monitoring of consumer
energy.
Rheo Systems, Pretoria Using Clojure for supply chain integration.

Companies In South Africa
Pattern Matched Technologies, Midrand Using Erlang for all
systems, eg. processing high volumes of ﬁnancial
transactions.
E↵ective Control Systems, Kyalami Using Erlang for printer
management.
Mira Networks, Somerset West Using Erlang for billing
administration and mobile development.
Kotive Using Scala for designing workﬂow processes.

Online Courses
Functional Thinking by Neal Ford
O’ Reilly
http://shop.oreilly.com/product/0636920030393.do
Functional Programming Principles in Scala
EPFL University
https://www.coursera.org/course/progfun
School of Haskell
FP Complete
https://www.fpcomplete.com/school
Programming Languages
University of Washington
https://www.coursera.org/course/proglang

Books
Miran Lipovaˇca
Learn You a Haskell for Great Good!
http://learnyouahaskell.com/
Fred H´ebert
Learn You Some Erlang for Great Good!
http://learnyousomeerlang.com/
Yaron Minski, Anil Madhavapeddy, Jason Hickey
Real World OCaml
https://realworldocaml.org/
Paul Chiusano, R´unar Bjarnason
Functional Programming in Scala
http://www.manning.com/bjarnason/

References I
John Hughes
Why Functional Programming Matters
http://www.cs.kent.ac.uk/people/staff/dat/miranda/
whyfp90.pdf
Dave Thomas
Programming Elixir, A Gentle Introduction
http://theprosegarden.com/part-1-of/
Joel Spolsky
Can Your Programming Language Do This?
http:
//www.joelonsoftware.com/items/2006/08/01.html

References II
Robert Martin
Functional Programming Basics
http://pragprog.com/magazines/2013-01/
functional-programming-basics
John Carmack
Functional Programming in C++
http://www.altdevblogaday.com/2012/04/26/
functional-programming-in-c/
Edsger W. Dijkstra
Go To Statement Considered Harmful
http://www.u.arizona.edu/~rubinson/copyright_
violations/Go_To_Considered_Harmful.html

References III
Tweet by Michael Feathers
https://twitter.com/mfeathers/status/29581296216
Alan Jay Perlis
http://www.cs.yale.edu/quotes.html
Rich Hickey
http:
//www.infoq.com/presentations/Simple-Made-Easy
Andreas Pauley
An Introduction to Functional Programming
https://github.com/apauley/fp_presentation

An Introduction to Functional Programming at the Jozi Java User Group

Recommended

More Related Content

What's hot (20)

Similar to An Introduction to Functional Programming at the Jozi Java User Group (20)

Recently uploaded (20)

An Introduction to Functional Programming at the Jozi Java User Group