Introduction to Functional Programming

An Introduction to Functional Programming
Andreas Pauley – @apauley
Pattern Matched Technologies
Lambda Luminaries @lambdaluminary
September 2, 2013
Andreas Pauley – @apauley (Pattern Matched TechnologiesLambda Luminaries @lambdaluminary)Functional Programming September 2, 2013 1 / 58

Pattern Matched Technologies
Developing ﬁnancial applications in Erlang.
http://www.patternmatched.com/

Lambda Luminaries – @lambdaluminary
Local functional programming user group
We meet once a month, on the second Monday of the month.
http://www.meetup.com/lambda-luminaries/

Introduction
Table of Contents
1 Introduction
2 Deﬁnition of Functional Programming
3 Function Recap
4 Common FP Idioms
Recursion
Pattern Matching
Higher-order Functions
5 Higher-order Functions and Lists
6 Advantages of Functional Programming
7 Disdvantages of Functional Programming
8 Companies using Functional Programming
9 Where do we go from here?

Introduction
A word from the wise
“ 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 [2]

Introduction
Quake

Introduction
A Few Functional Programming Languages
Haskell Strong focus on functional purity. Lazy evaluation.
Advanced static type system. Native-code compiler.

Introduction
Erlang Focused around concurrency and distributed programming.
Strict evaluation. Dynamic typing. Runs on the BEAM VM.

Introduction
Clojure A modern Lisp language. Focus on concurrency. Lazy
evaluation. Dynamic typing. Runs on the JVM.

Introduction
Scala FP and OO. Strict evaluation by default, but supports lazy
evaluation. Advanced static type system. Runs on the JVM.

Introduction
OCaml FP and OO. Part of the ML family. Sometimes claimed to
be “faster than C”. Strict evaluation. Advanced static type
system. Native-code compiler.

Introduction
OCaml FP and OO. Part of the ML family. Sometimes claimed to
be “faster than C”. Strict evaluation. Advanced static type
system. Native-code compiler.
F# FP and OO. Based on OCaml. Strict evaluation by default,
but supports lazy evaluation. Advanced static type system.
Runs on the .NET CLR.

Deﬁnition of Functional Programming
Table of Contents
1 Introduction
3 Function Recap
4 Common FP Idioms
Recursion
Pattern Matching

So what exactly is Functional Programming?

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

When programming in a functional style/language:
You can’t vary your variables.

You can’t mutate or change your state.

No while/for loops, sorry.

You can’t have side-eﬀects.

You can’t have side-eﬀects.
You can’t control the order of execution (lazy evaluated languages).

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, 3]
Also framed in the negative (you can’t).

GOTO 10
This sounds like
In hindsight we don’t really need GOTO’s.

GOTO 10
This sounds like
In hindsight we don’t really need GOTO’s.
In hindsight it is not about what you cannot do.

Structured Programming and Functional Programming
Structured Programming introduced subroutines with ﬁxed entry/exit
points (instead of GOTO’s), resulting in improved
modularity.

Structured Programming and Functional Programming
Structured Programming introduced subroutines with ﬁxed entry/exit
points (instead of GOTO’s), resulting in improved
modularity.
Functional Programming provides similar important beneﬁts – more about
this later.

We need a better deﬁnition for Functional Programming.

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?

Function Recap
Table of Contents
1 Introduction
3 Function Recap
4 Common FP Idioms
Recursion
Pattern Matching

Function Recap
An example function
f (x) = 2x + 3

Function Recap
Variables in functions
f (x) = 2x + 3
When we evaluate the function:
f (4) = 2 ∗ 4 + 3 = 11

Function Recap
f (x) = 2x + 3
f (4) = 2 ∗ 4 + 3 = 11
The value of x will not change inside the function body.

Function Recap
f (x) = 2x + 3
f (4) = 2 ∗ 4 + 3 = 11
No x = 4 and later x = 21 in the same function body.

Function Recap
f (x) = 2x + 3
f (4) = 2 ∗ 4 + 3 = 11
Same input, same output. Every time.

Function Recap
f (x) = 2x + 3
f (4) = 2 ∗ 4 + 3 = 11
Same input, same output. Every time.
In other words, we can replace any occurrence of f (4) with 11
(Referential Transparency)

Function Recap
Functions can call other functions
g(x) = f (x) + 1

Function Recap
Values are functions
Constant values are just functions with no input parameters
k = 42
def k():
return 42

Function Recap
Functions can be combined
h(x) = f (g(x))

Function Recap
Functions can take functions as input and/or return
functions as the result.
h(p, q, x) = p(x) + q(2)

Function Recap
Functions can take functions as input and/or return
functions as the result.
h(p, q, x) = p(x) + q(2)
h(f , g, 3) = f (3) + g(2)

Function Recap
The derivative of cos(x) returns another function.
d
dx cos(x) = − sin(x)

Function Recap
A functional program consists entirely of functions
def main(args):
result = do_something_with_args(args)
print result
def do_something_with_args(args):
return ’-’.join(args[1:])
./justfunctions.py hello functional programming
hello-functional-programming

Function Recap
A functional program consists entirely of functions
main :: IO()
main = do
args <- getArgs
let result = do_something_with_args args
putStrLn result
do_something_with_args :: [String] -> String
do_something_with_args args = intercalate "-" args
./justfunctions hello functional programming
hello-functional-programming

Common FP Idioms
Table of Contents
1 Introduction
3 Function Recap
4 Common FP Idioms
Recursion
Pattern Matching

Common FP Idioms Recursion
Recursive function: Haskell
doubleAll :: Num a => [a] -> [a]
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: 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]

An iterative version in Python
def doubleAll(numbers):
doubled = []
for num in numbers:
doubled.append(num * 2)
return doubled

Common FP Idioms Pattern Matching
Pattern Matching: Haskell
doubleAll [] = []

Common FP Idioms Higher-order Functions
Higher-order functions: Python
f (x) = 2x + 3
g(x) = f (x) + 1
h(p, q, x) = p(x) + q(2)
def f(x):
return (2*x) + 3
def g(x):
return f(x) + 1
def h(func_a, func_b, x):
return func_a(x) + func_b(2)

Common FP Idioms Higher-order Functions
Higher-order functions: Haskell
f (x) = 2x + 3
g(x) = f (x) + 1
h(p, q, x) = p(x) + q(2)
f x = (2*x) + 3
g x = (f x) + 1
h :: (Int->Int) -> (Int->Int) -> Int -> Int
h func_a func_b x = (func_a x) + (func_b 2)

Higher-order Functions and Lists
Table of Contents
1 Introduction
3 Function Recap
4 Common FP Idioms
Recursion
Pattern Matching

3 Basic List Operations
Map Convert each element of a list into some other value.
Example: Convert a list of students to a list of exam scores.

Filter Get a subset of a list based on some condition. Example:
Filter the entire list of students down to only those that
passed the exam.

Filter Get a subset of a list based on some condition. Example:
Filter the entire list of students down to only those that
passed the exam.
Fold Reduce a list of items to a single value. Example: Reduce
the list of students to a single string of all names.

Map
doubleAll [] = []
Looks very similar to the builtin map function:
map :: (a -> b) -> [a] -> [b]
map _ [] = []
map f (x:xs) = f x : map f xs
So our doubleAll can actually be simpliﬁed as:
doubleAll = map (*2)

Student Data
data Student = Student { firstName :: String
, lastName :: String
, finalExamScore :: Double}

Student Data
[Student {firstName="John",
lastName="Deer",
finalExamScore=60},
Student {firstName="Billy",
lastName="Bob",
finalExamScore=49.1},
Student {firstName="Jane",
lastName="Doe",
finalExamScore=89},
Student {firstName="Jack",
lastName="Johnson",
finalExamScore=29.3}]

Map
Map type signature:
map :: (a -> b) -> [a] -> [b]
Map on student data:
allscores :: [Student] -> [Double]
allscores students = map finalExamScore students
ﬁnalExamScore type signature:
finalExamScore :: Student -> Double
Output:
Final Exam Scores: [60.0,49.1,89.0,29.3]

Filter
Filter type signature:
filter :: (a -> Bool) -> [a] -> [a]
Filter on student data:
passed :: [Student] -> [Student]
passed students = filter has_passed students
has_passed :: Student -> Bool
has_passed student = finalExamScore student >= 60
Output:
Students that have passed:
[John Deer (60.0),Jane Doe (89.0)]

Fold
Fold type signature:
foldl :: (a -> b -> a) -> a -> [b] -> a
Fold on student data:
namecat :: [Student] -> String
namecat students = foldl catfun "" students
catfun :: String -> Student -> String
catfun acc student = acc ++ (firstName student) ++ "n"
Output:
"JohnnBillynJanenJackn"

Shortened Map, Filter, Fold
allscores = map finalExamScore
passed = filter has_passed
has_passed student = finalExamScore student >= 60
namecat = foldl catfun ""
where catfun = (acc student ->
acc ++ (firstName student) ++ "n")

Imperative Filter Example
class Student:
def __init__(self, firstname, lastname, finalexamscore):
self.firstname = firstname
self.lastname = lastname
self.finalexamscore = finalexamscore
def has_passed(self):
return self.finalexamscore >= 60
def passed(students):
passed_students = []
for student in students:
if student.has_passed():
passed_students.append(student)
return passed_students

Advantages of Functional Programming
Table of Contents
1 Introduction
3 Function Recap
4 Common FP Idioms
Recursion
Pattern Matching

Perlisism #19
“ A language that doesn’t aﬀect the way you think about
programming, is not worth knowing. ”
— Alan Perlis[5]

Changes the way you think about programming and problem solving.

Improvements on the types of abstractions we can do with eg.
higher-order functions.

Lock-free concurrency.

Improved ways of testing - QuickCheck.

More eﬀective reasoning about code.

More eﬀective reasoning about code.
Declare possible Null values explicitly if you need them. Goodbye
NullPointerException (mostly).

Disdvantages of Functional Programming
Table of Contents
1 Introduction
3 Function Recap
4 Common FP Idioms
Recursion
Pattern Matching

Disadvantages of Functional Programming
Steep learning curve.

There are some very cryptic concepts.

Tools/IDE’s are not as advanced as the mainstream equivalents.

Tools/IDE’s are not as advanced as the mainstream equivalents.
Order of execution may be diﬃcult to reason about in a lazy language.

Unfamiliar Territory
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[6]

Companies using Functional Programming
Table of Contents
1 Introduction
3 Function Recap
4 Common FP Idioms
Recursion
Pattern Matching

Companies In South Africa
Pattern Matched Technologies, Midrand Using Erlang for all systems, eg.
processing high volumes of ﬁnancial transactions.

Eldo Energy, Johannesburg Using Clojure for automated meter reading
and intelligent monitoring of consumer energy.

Rheo Systems, Pretoria Using Clojure for supply chain integration.

Yuppiechef, Cape Town Using Clojure for their Warehouse Management
System.

System.
Eﬀective Control Systems, Kyalami Using Erlang for printer management.

System.
Mira Networks, Somerset West Using Erlang for billing administration and
mobile development.

System.
Mira Networks, Somerset West Using Erlang for billing administration and
mobile development.
Amazon.com, Cape Town Using Scala in EC2.

Where do we go from here?
Table of Contents
1 Introduction
3 Function Recap
4 Common FP Idioms
Recursion
Pattern Matching

Lambda Luminaries – @lambdaluminary
Local functional programming user group
We meet once a month, on the second Monday of the month.
http://www.meetup.com/lambda-luminaries/

Online Courses
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
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 II
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

Introduction to Functional Programming

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (8)

En vedette

En vedette (20)

Similaire à Introduction to Functional Programming

Similaire à Introduction to Functional Programming (20)

Dernier

Dernier (20)

Introduction to Functional Programming