Functional Programming In Practice

Func%onal Programming
In Prac%ce
Michiel Borkent
@borkdude
Hogeschool Utrecht
May 9th 2016

Agenda
●  Func>onal Programming
●  Haskell, Scala, Clojure
●  Full stack example using Clojure

First, what is FP?
•  First class func>ons
•  Pure func>ons
•  Immutable values
•  No or few side eﬀects

First class func%ons
Func>ons can be created on the ﬂy

scala> val f = (x: String) => "Hello " + x
f: String => String = <function1>

scala> f("World")
res10: String = Hello World

First class func%ons
Func>ons can be passed around as values

List("Clojure","Scala","Haskell").map(f)
res: List(Hello Clojure, Hello Scala, Hello Haskell)

Pure func%ons
Func>on with same input always yields the output:

f(x) == y, always

Not a pure func%on
scala> val f = (i: Int) => Math.random() * i
f: Int => Double = <function1>

scala> f(1)
res14: Double = 0.13536266885499726

scala> f(1)
res15: Double = 0.4086671423543593

A pure func%on?
val add = (x: Int, y: Int) => x + y
add(1,2) // 3

A pure func%on?
class MutableInt(var i: Int) {
override def toString = i.toString
}

val add = (x: MutableInt, y: MutableInt): MutableInt =>
new MutableInt(x.i + y.i)

val x = new MutableInt(1)
val y = new MutableInt(2)

add(x,y) // MutableInt = 3

A pure func%on? No!
You cannot build pure func>ons with mutable objects.


x.i = 2


add(x,y) does not always yield the same result!
This is why we need immutable values in Func>onal Programming.

A pure func%on?
List(1,2,3) is immutable.

def addZero(l: List[Int]) = 0 :: l

addZero(List(1,2,3)) // List(0, 1, 2, 3)

Immutable data structures
Int, String, etc are already immutable

0 :: List(1,2,3) // List(0,1,2,3)
Vector(1,2,3) :+ 4 // Vector(1,2,3,4)
Set(1,2,3) + 4 // Set(1,2,3,4)

Eﬃcient by re-using structure internally

source: hVp://hypirion.com/musings/understanding-persistent-vector-pt-1

Systems and immutability
•  Each system receives a message
and/or sends a message
•  Muta>ng a message does not
aﬀect other system
•  In tradi>onal OO references lead
to uncontrolled muta>on, also
called spooky ac>on at a distance
•  You can protect yourself by
using Value Objects or DTOs,
but takes work
•  Immutable data structures
solve this problem

•  State modifica>on
•  Observable ac>on

Examples:
•  Modifying a variable
•  Wri>ng to a file
Side effects

•  Pure func>ons have no side effects
•  Side effects are difficult to test (without mocks)
•  Pure FP languages make side effects explicit
•  FP languages isolate/minimize side effects
Side effects

Where are the side eﬀects?
class Program extends App {
var x: Int = 1
def mutateX = {
x = (Math.random * 100).toInt
}
mutateX
println(x)
}

Why Func%onal Programming?
•  Makes codes easier to reason about
•  Easier to test
•  More expressive, less code = less bugs
•  BeVer suited for parallellisa>on and concurrency

Examples in Haskell, Scala and Clojure
•  Deﬁne a new type Person
•  Create a list of Persons
•  Count total length of ﬁrst names with length
greater than 4

hVps://github.com/borkdude/fp-hu-may-2016/blob/master/code

Degrees of FP
Nirvana
Unsafe Safe
Useless
Useful C#, Java
Haskell
Scala
Clojure
SQL, Linq
Simon Peyton Jones, FP researcher

Learning FP
Choose a language that encourages FP

Apply the concepts in your favorite language
‘Think like a fundamentalist, code like a hacker’ – Erik Meijer
Haskell Pure, lazy,
statically typed
Clojure Not pure. FP + Lisp on JVM,
dynamically typed
Scala Not pure. FP + (immutable) OO on
JVM, statically typed

Clojure resources
http://michielborkent.nl/clojurecursus

Scala resources
Functional Programming in Scala Coursera MOOC

Developers love FP
Source: http://stackoverflow.com/research/developer-survey-2016

Companies want FP devs
Source: http://stackoverflow.com/research/developer-survey-2016

Once you know FP
… you can apply and see it everywhere

FP at my job
•  Microservices in Scala
•  UI in JavaScript using React, ImmutableJS and
Redux

Functional Programming In Practice

Clojure
•  dynamic language
•  Lisp
•  func>onal programming
•  immutable data structures
•  strong concurrency support
•  embraces host plajorm (JVM, js)
•  EDN

Clojure in industry
hVps://www.youtube.com/watch?v=av9Xi6CNqq4

http://dev.clojure.org/display/community/Clojure+Success+Stories
https://www.youtube.com/watch?v=iUC7noGU1mQ

Data literals
Keyword: :a
Vector: [1 2 3 4]
Hash map: {:a 1, :b 2}
Set: #{1 2 3 4}
List: '(1 2 3 4)

Extensible Data Nota%on
{:key1"Bar"
:key2 [1 2 3]
"key3", #{1.0 2.0 c}
:key4,{:foo {:bar {:baz 'hello}}}}

(pr-str {:foo "bar"})
(read-string "{:foo "bar"}")

Syntax
if (...) {
...
} else { ->
...
}

(if ...
...
...)

Syntax
var foo = "bar";

(def foo "bar")

JavaScript - ClojureScript
if (bugs.length > 0) {
return 'Not ready for release';
} else {
return 'Ready for release';
}

(if (pos? (count bugs))
"Not ready for release"
"Ready for release")
source: hVp://himera.herokuapp.com/synonym.html

JavaScript - ClojureScript
var foo = {bar: "baz"};
foo.bar = "baz";
foo["abc"] = 17;

alert('foo')
new Date().getTime()
new
Date().getTime().toString()

(def foo (js-obj "bar" "baz"))
(set! (.-bar foo) "baz")
(aset foo "abc" 17)

(js/alert "foo")
(.getTime (js/Date.))
(.. (js/Date.) (getTime)
(toString))
source: hVp://himera.herokuapp.com/synonym.html

Persistent data structures
(def v [1 2 3])
(conj v 4) ;; => [1 2 3 4]
(get v 0) ;; => 1
(v 0) ;; => 1

Persistent data structures
(def m {:foo 1 :bar 2})
(assoc m :foo 2) ;; => {:foo 2 :bar 2}
(get m :foo) ;;=> 1
(m :foo) ;;=> 1
(:foo m) ;;=> 1
(dissoc m :foo) ;;=> {:bar 2}

Func%onal programming
(def r (->>
(range 10) ;; (0 1 2 .. 9)
(filter odd?) ;; (1 3 5 7 9)
(map inc))) ;; (2 4 6 8 10)
;; r is (2 4 6 8 10)

Func%onal programming
;; r is (2 4 6 8 10)
(reduce + r)
;; => 30
(reductions + r)
;; => (2 6 12 20 30)

var sum = _.reduce(r, function(memo, num){ return memo + num; });

Sequence abstrac%on
Data structures as seqs
(first [1 2 3]) ;;=> 1
(rest [1 2 3]) ;;=> (2 3)
General seq func>ons: map, reduce, filter, ...
(distinct [1 1 2 3]) ;;=> (1 2 3)
(take 2 (range 10)) ;;=> (0 1)

See hVp://clojure.org/cheatsheet for more

Sequence abstrac%on
Most seq func>ons return lazy sequences:

(take 2 (map
(fn [n] (js/alert n) n)
(range)))
inﬁnite lazy sequence of numbers
side eﬀect

Mutable state: atoms
(def my-atom (atom 0))
@my-atom ;; 0
(reset! my-atom 1)
(reset! my-atom (inc @my-atom)) ;; bad idiom
(swap! my-atom (fn [old-value]
(inc old-value)))
(swap! my-atom inc) ;; same
@my-atom ;; 4

Lisp: macros
(map inc
(filter odd?
(range 10)))

(->>
(range 10)
(filter odd?)
(map inc))
thread last macro

Lisp: macros
(macroexpand
'(->> (range 10) (filter odd?)))

;; => (filter odd? (range 10))

(macroexpand
'(->> (range 10) (filter odd?) (map inc)))

;; => (map inc (filter odd? (range 10)))

Lisp: macros
JVM Clojure:

(defmacro defonce [x init]
`(when-not (exists? ~x)
(def ~x ~init)))

ClojureScript:

(defonce foo 1)
(defonce foo 2) ;; no effect
notes:
●  macros must be wriVen in JVM Clojure
●  are expanded at compile >me
●  generated code gets executes in ClojureScript

Ar%kel in Java Magazine over Clojure
hVp://michielborkent.nl/nljug/18_21_Clojure.pdf

Demo %me!
https://github.com/borkdude/fp-hu-may-2016

Functional Programming In Practice

Recommended

More Related Content

What's hot (20)

Similar to Functional Programming In Practice (20)

More from Michiel Borkent (6)

Recently uploaded (20)

Functional Programming In Practice