The document discusses functional programming from a Clojurian perspective. It provides an overview of Clojure syntax including lists, vectors, maps, and sets. It also covers Clojure concepts like homoiconicity, where code is represented as data in lists. Functions are first-class citizens in Clojure and functions can be defined, consumed, and are used throughout the language to process data.

1. On Functional Programming
A Clojurian Perspective
Raju Gandhi

2. Disclaimers

3. Disclaimers
I tend to speak fast

4. Disclaimers
I tend to speak fast
I may have an accent

5. (struct-map Speaker
:name "raju",
:pronunciation "/raa-jew/",
:description ["java/ruby developer",
"technophile",
"language geek"],
:profiles {:twitter "looselytyped"
:facebook "raju.gandhi"})

6. About us...
Small consulting/training/mentoring shop
Based out of Ohio and Arizona
Specialize in open-source technologies -
Java/Ruby/Rails/Groovy/Grails

7. Clojure?
Lisp on the JVM
Dynamic
Excellent concurrency support
Strong Java inter-op
Lazy*

8. Clojure Syntax
A whirlwind tour

9. Clojure Syntax
;lists - these are special
'(+ 1 2 1/3)
;a comment
["this" "is" "a" "vector"]
;commas are whitespace
{:yes true, :no false, :null nil}
;sets
#{a e i o u}

10. Clojure Syntax
;lists - these are special
'(+ 1 2 1/3)
;a comment
["this" "is" "a" "vector"]
;commas are whitespace
{:yes true, :no false, :null nil}
;sets
#{a e i o u}

11. Clojure Syntax
;lists - these are special
'(+ 1 2 1/3)
;a comment
["this" "is" "a" "vector"]
;commas are whitespace
{:yes true, :no false, :null nil}
;sets
#{a e i o u}

12. Clojure Syntax
;lists - these are special
'(+ 1 2 1/3)
;a comment
["this" "is" "a" "vector"]
;commas are whitespace
{:yes true, :no false, :null nil}
;sets
#{a e i o u}

13. Clojure Syntax
;lists - these are special
'(+ 1 2 1/3)
;a comment
["this" "is" "a" "vector"]
;commas are whitespace
{:yes true, :no false, :null nil}
;sets
#{a e i o u}

14. LISt Processing
;can be a regular function
;Yes! + is a function :)
(+ 1 2 3)
;or a special form
(if (< x 3) "less than 3" "or not")
;or a macro
(defn say-hello [name]
(str "Hello, " name))

15. LISt Processing
;can be a regular function
;Yes! + is a function :)
(+ 1 2 3)
;or a special form
(if (< x 3) "less than 3" "or not")
;or a macro
(defn say-hello [name]
(str "Hello, " name))

16. LISt Processing
;can be a regular function
;Yes! + is a function :)
(+ 1 2 3)
;or a special form
(if (< x 3) "less than 3" "or not")
;or a macro
(defn say-hello [name]
(str "Hello, " name))

17. LISt Processing
;can be a regular function
;Yes! + is a function :)
(+ 1 2 3)
;or a special form
(if (< x 3) "less than 3" "or not")
;or a macro
(defn say-hello [name]
(str "Hello, " name))

18. LISt Processing
;can be a regular function
;Yes! + is a function :)
(+ 1 2 3)
;or a special form
(if (< x 3) "less than 3" "or not")
;or a macro
(defn say-hello [name]
(str "Hello, " name))

19. LISt Processing
;can be a regular function
;Yes! + is a function :)
(+ 1 2 3)
;or a special form
(if (< x 3) "less than 3" "or not")
;or a macro
(defn say-hello [name]
(str "Hello, " name))

20. LISt Processing
;can be a regular function
;Yes! + is a function :)
(+ 1 2 3)
;or a special form
(if (< x 3) "less than 3" "or not")
;or a macro
(defn say-hello [name]
(str "Hello, " name))

21. Homoiconicity
;defining a function
(defn say-hello [name]
(str "Hello, " name))

22. Homoiconicity
;defining a function
(defn say-hello [name]
(str "Hello, " name))

23. Homoiconicity
;defining a function
(defn say-hello [name]
(str "Hello, " name))

24. Homoiconicity
;defining a function
(defn say-hello [name]
(str "Hello, " name))

25. Homoiconicity
code == data

26. What is FP?

27. What is FP?
What is OOP???

28. What is FP?
What is OOP???
Functional programming

29. What is FP?
What is OOP???
Functional programming
Functions are first class citizens

30. Why FP?
Compartmentalize
Better re-use
Referential Transparency
Easier to test
Easier to parallelize

31. Clojure’s Approach
Side effects are explicit
State manipulation via
Persistent data-structures
Multiple reference types with
appropriate semantics

32. Declaring Functions
;explicit definition
(defn times-2
"Multiplies its arg by 2"
[n]
(* 2 n))

33. Declaring Functions
;alternate approach
;no docs though
(def times-2
(fn [n] (* 2 n)))

34. Declaring Functions
;anonymous function
(map #(* 2 %) [1 2 3])

35. Declaring Functions
;anonymous function
(map #(* 2 %) [1 2 3])

36. Consuming Functions
;map takes ([f coll] ...)
(map times-2 [1 2 3])
;> (2 4 6)

37. Consuming Functions
;map takes ([f coll] ...)
(map #(* 2 %) [1 2 3])
;> (2 4 6)

38. Consuming Functions
;reduce takes ([f coll] ...)
(reduce + [1 2 3])
;> 6

39. Functions Everywhere
([4 5 6] 0)
;> 4
(#{a e i o u} a)
;> a
({:yes true, :no false, :null nil} :yes)
;> true
(:yes {:yes true, :no false, :null nil})
;> true

40. A Small Digression
(let [x 1, y 2] (str x " " y))
;> ”1 2”
(let [[x y] [1 2]] (str x " " y))
;> "1 2"
(let [[x & more] [1 2 3]] (str x " " more))
;> "1 (2 3)"

41. Looping
(defn min-in-coll [x & more]
(loop [min x
[f & others] more]
(if f
(recur (if (< min f) min f) others)
min)))
;(min-in-coll [3 4 2 -1])
;> -1

42. Thanks!