Functional Programming with Clojure

with
by
Carlo Sciollaskuro@skuro.tk

with
Carlo Sciollaskuro@skuro.tk
works for
organisesfrom

The package contains
● functions as values
● immutable (persistent) data structures
● pure functions
● recursion
● lazy evaluation
with

with
The package contains
● pure functions
● recursion
● lazy evaluation

with
Brief intro to Clojure
● I will trade precision for clarity
● there’s much more to know
● one huge missing topic: the REPL
● you can try this at home

with
Clojure data anatomy
1 2.0 3/4 ; numbers
foo bar ; symbols
:one :two ; keywords
“value” ; strings
true false ; bools
a b c ; chars
nil ; null

with
Clojure data anatomy
[1 2 3] ; vector
‘(foo bar) ; list
#{:one :two} ; set
{:key “value”} ; map

with
Clojure code anatomy
(* 132.715
(- 1.06 1.02))
-> 5.308600000000005
nested unquoted lists, in facts:
“The name LISP derives from "LISt Processing".” -- Wikipedia

with
Clojure code anatomy
(* 132.715
(- 1.06 1.02))
-> 5.308600000000005
no “return”: everything
is an expression

with
Clojure beer anatomy
(* 132.715
(- 1.06 1.02))
-> 5.31º
Alcohol by volume formula (Wikipedia):

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
(* 132.715
(- 1.06 1.02))
*
132.
715 -
1.06 1.02

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
(* 132.715
(- 1.06 1.02))
STAR
132.
715 -
1.06 1.02
The symbol * evaluates to:
clojure.core/_STAR_

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
(* 132.715
(- 1.06 1.02))
STAR
132.
715 -
1.06 1.02
Values evaluate to themselves

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
(* 132.715
(- 1.06 1.02))
STAR
132.
715 -
1.06 1.02

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
(* 132.715
(- 1.06 1.02))
STAR
132.
715
SUB
1.06 1.02
The symbol - evaluates to:
clojure.core/_

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
(* 132.715
(- 1.06 1.02))
STAR
132.
715
SUB
1.06 1.02
Values evaluate to themselves

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
(* 132.715
(- 1.06 1.02))
STAR
132.
715
SUB
1.06 1.02
All args evaluated? Function call!

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
(* 132.715
(- 1.06 1.02))
STAR
132.
715
0.04

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
5.31
(* 132.715
(- 1.06 1.02))

with
The Reader
Or:
How
I
Learned
To
Stop
Worrying
And
Love
The
Eval
(* 132.715
(- 1.06 1.02))

with
Naming stuff: global bindings
(def scalar 42)
(def fun
(fn [a b] (+ a b)))
(defn moar-fun [a b]
(+ a b)))

with
Naming stuff: lexical bindings
(let [one “one”
key (keyword one)]
key)
; => :one

with
Ready to go
● pure functions
● recursion
● lazy evaluation

with
Functional schmunctional
● pure functions
● recursion
● lazy evaluation
(defn compose [f g]
(fn [x] (f (g x))))

with
● pure functions
● recursion
● lazy evaluation
(defn compose [f g]
(fn [x] (f (g x))))
returns a function
accepts functions in input

with
● pure functions
● recursion
● lazy evaluation
(defn compose [f g]
(fn [x] (f (g x))))
((compose inc dec) 42)
; => 42

with
● pure functions
● recursion
● lazy evaluation
(let [foo [{:pi 3.14}
{:g 9.8}]]
(conj foo {:phi 1.62}))
; => [{:pi 3.14} {:g 9.8} {:phi 1.63}]

with
● pure functions
● recursion
● lazy evaluation
(let [foo [{:pi 3.14}
{:g 9.8}]]
(conj foo {:phi 1.62})
(count foo)) ; => 2
3.14:pi
foo foo’
9.8:g 1.62:phi

with
● pure functions
● recursion
● lazy evaluation
(doseq [_ (range 2000)]
(inc 41)) ; => always 42
For a given input, pure functions yield the same result,
making them dead-easy to maintain and prove correct

with
● pure functions
● recursion
● lazy evaluation
(doseq [_ (range 2000)]
(rand)
(http/GET “http://...”))
Impure code enables interaction, but introduces side effects
which make your program harder to test and reason about

with
● pure functions
● recursion
● lazy evaluation
(defn my-inc [[h & t]]
(when h
(cons (inc h)
(my-inc t))))
recursive call

with
● pure functions
● recursion
● lazy evaluation
(when h
(cons (inc h)
(my-inc t))))exit condition

with
● pure functions
● recursion
● lazy evaluation
destructuring:
pattern-match your input
(when h
(cons (inc h)
(my-inc t))))

with
● pure functions
● recursion
● lazy evaluation
def my-inc(s) {
def res = []
for(i in s)
res << i + 1
res
}
(when h
(cons (inc h)
(my-inc t))))

with
What if the input is infinite?
(when h
(cons (inc h)
(my-inc t))))

with
Kaboom!
(when h
(cons (inc h)
(my-inc t))))
with no tail call optimisation (TCO),
recursive invocations blows up the stack

with
Working around the lack of TCO
(defn my-inc [s]
(loop [res () rem s]
(let [[h & t] rem]
(if h
(recur (cons (inc h) res) t)
res))))

with
Working around the lack of TCO
(defn my-inc [s]
(loop [res () rem s]
(let [[h & t] rem]
(if h
(recur (cons (inc h) res) t)
res))))
ECMAScript 6
Java 9 (?)

with
● pure functions
● recursion
● lazy evaluation
(defn lazy-inc [[h & t]]
(lazy-seq
(when h
(cons (inc h)
(lazy-inc t))))

with
● pure functions
● recursion
● lazy evaluation
(lazy-seq
(when h
(cons (inc h)
(lazy-inc t))))
retuns a “thunk”

with
What if the input is infinite?
(lazy-seq
(when h
(cons (inc h)
(lazy-inc t)))))

with
Thanks!
Carlo Sciolla
p r o f e s s i o n a l t i n k e r e r
https://twitter.com/skuro
https://github.com/skuro
http://skuro.tk
http://amsclj.nl

Functional Programming with Clojure

More Related Content

What's hot

Viewers also liked

Similar to Functional Programming with Clojure

More from Carlo Sciolla

Recently uploaded

Functional Programming with Clojure