The document discusses how applying object-oriented (OO) design principles can often lead to functional design when using Clojure. It provides examples of how single responsibility, interface segregation, and dependency inversion translate to more modular functional designs using namespaces, protocols, multimethods, and partial function application. Polymorphism in Clojure is more flexible than OO polymorphism through protocols and multimethods. State management can be modeled functionally using atoms to manage immutable state. Overall, Clojure allows embracing many benefits of OO and functional design together.

1.
( life w/o objects )
( oop → functional design )
( with clojure )
(Osvaldas Grigas | )@ogrigas

2. (oop hangover)

4. type systems

5. "hybrid" languages

6. (design)

7. (monolithic design)

8. (modular design)

9. (design process)
Before A er

10. (oo design)
Noun-oriented
Verb-oriented

11. (nouns)
CustomerDAO
CustomerService
CustomerController

12. (verbs)
RegisterCustomer
PromoteCustomerToVIP
RenderCustomerProfilePage

13. Domain-driven Design?
"As a teller, I want to transfer funds between accounts."

14. (oo design principles)
Single Responsibility
Interface Segregation
Dependency Inversion

15. (single responsibility)

16. public class ZipDownloadService {
List<File> downloadAndExtract(String location) {
...
}
}

17. public class FileDownloader {
List<File> downloadFiles(String location) {
...
}
}
public class ZipExtractor {
File extractZip(File archive) {
...
}
}

18. Or ... just functions
(defn download­files [location]
(...))
(defn extract­zip [archive]
(...))

19. (clojure)
in a nutshell

20. (clojure)
in a nutshell
calculate(5,2,9)

21. (clojure)
in a nutshell
(calculate 5,2,9)

22. (clojure)
in a nutshell
(calculate 5 2 9)

23. (function definition)
(defn calculate [a b c]
(+ a (* b c)))

24. (interface segregation)

25. public class ProductCatalog
{
public void Save(Product product)
{
...
}
public Product FindById(int productId)
{
...
}
}

26. public class ProductSaver
{
public void Save(Product product)
{
...
}
}
public class ProductFinder
{
public Product FindById(int id)
{
...
}
}

27. Somethin' ain't right

28. public class ProductRepository
{
public void Save(Product product)
{
...
}
}
public class ProductQuery
{
public Product FindById(int id)
{
...
}
}

29. Feelin' good now

30. Or ... just functions
(defn save­product [product]
(...))
(defn find­product­by­id [id]
(...))

31. Applying OO design principles
o en leads to
functional design

32. (what's missing)

33. (what's missing)
Code organization
Inheritance
Encapsulation
Composition
Polymorphism
State management

34. (code organization)

35. (ns my.product.repository)
(defn save [product]
(...))
(defn find­by­id [id]
(...))
(ns my.other.namespace
(:require [my.product.repository :as product­repo]))
(product­repo/find­by­id 42)

36. (inheritance)

37. (inheritance)
just don't

38. (encapsulation)

39. (encapsulation)
Data is not an object

40. (encapsulation)
Data is not an object
Data is immutable

41. (html [:body
[:h1 "Employees"]
[:ul
(for [person employees]
[:li
[:h2 (:name person)]
[:p (:email person)]])]])

42. (defn handle [request]
{:status 200
:headers {"Content­Type" "application/json"
"X­Custom­Header" "12345"}
:body (json/generate­string
{:name "John Wick"
:age 42
:email "john@wick.name"
:hobbies ["guns" "dogs" "judo"]})})

43. append-child array-map assoc associative? assoc-in bean bigdec bigint biginteger bit-and bit-and-not bit-clear
bit-flip bit-not bit-or bit-set bit-shi -le bit-shi -right bit-test bit-xor blank? branch? butlast byte capitalize cat
char char? char-escape-string char-name-string children coll? compare concat conj cons contains? count
counted? cycle dec dec' decimal? dedupe dense-int-set diff difference disj dissoc distinct distinct? double
down drop drop-last drop-while edit eduction empty empty? end? enumeration-seq escape even? every?
false? ffirst file-seq filter filterv find find-keyword first flatten float float? fnext for format frequencies gensym
get get-in group-by hash-map hash-set identical? inc inc' index insert-child insert-le insert-right int integer?
interleave interpose intersection int-map into into-array int-set iterate iterator-seq join keep keep-indexed key
keys keyword keyword? last lazy-cat lazy-seq le le most le s line-seq list list? list* long lower-case make-
node map map? mapcat map-indexed map-invert mapv max max-key merge merge-with min min-key mod
neg? next nfirst nil? nnext node not not= not-any? not-empty not-every? nth nthnext nthrest num number?
odd? partition partition-all partition-by path peek pmap pop pos? postwalk postwalk-demo postwalk-replace
prev prewalk prewalk-demo prewalk-replace priority-map project quot rand rand-int rand-nth random-sample
range ratio? rational? rationalize reduce reduce-kv reductions re-find re-groups rem re-matcher re-matches
remove rename rename-keys re-pattern repeat repeatedly replace replace-first re-quote-replacement re-seq
rest resultset-seq reverse reversible? right rightmost rights root rseq rsubseq second select select-keys seq
seq? seque sequence sequential? seq-zip set set? short shuffle some some? sort sort-by sorted? sorted-map
sorted-map-by sorted-set sorted-set-by split split-at split-lines split-with str string? subs subseq subset?
subvec superset? symbol symbol? take take-last take-nth take-while to-array-2d transduce tree-seq trim triml
trim-newline trimr true? unchecked-add unchecked-dec unchecked-inc unchecked-multiply unchecked-
negate unchecked-subtract union unsigned-bit-shi -right up update update-in upper-case val vals vec vector
vector? vector-of vector-zip walk when-first xml-seq xml-zip zero? zipmap

44. (composition)

46. (dependency inversion)
Good for decoupling
Good for isolated testing

47. (oo dependencies)
public class ProfilePage {
String render(Repository repo, int customerId) {
return toHtml(repo.loadProfile(customerId));
}
}
Repository repo = new SqlRepository();
ProfilePage page = new ProfilePage();
String html = page.render(repo, customerId);

48. (fp dependencies)
(defn render­page [repository­fn customer­id]
(to­html (repository­fn customer­id)))
(defn load­from­sql [customer­id]
(...))
(render­page load­from­sql customer­id)

49. (basic fp polymorphism)
All functions implement the "Strategy" pattern

50. (oo composition)
Repository repo = new SqlRepository();
ProfilePage page = new ProfilePage(repo);
page.render(customerId);

51. (function closure)
(defn inject [f arg1]
(fn [arg2] (f arg1 arg2)))
(def render­from­db
(inject render­page load­from­sql))
(render­from­db customer­id)

52. (partial application)
(def render­from­db
(partial render­page load­from­sql))
(render­from­db customer­id)

53. "Object is a collection of partially-applied functions."
( J.B. Rainsberger )

54. (structural patterns)
Adapter
Decorator
...

55. ("adapter" pattern)
(defn to­view­model [profile] (...))
(render­page (comp to­view­model load­from­sql) id)

56. ("decorator" pattern)
(defn traceable [f]
(fn [& args]
(log/trace "Called with params:" args)
(apply f args)))
(render­page (traceable load­from­sql) id)

57. (polymorphism)

59. (oo polymorphism)
"Subtype Polymorphism"
(dispatch on the type of first argument)

60. public interface JsonObj {
String toJson();
}

61. public class JsonString implements JsonObj {
private final String value;
public JsonString(String value) {
this.value = value;
}
public String toJson() {
return """ + value + """;
}
}

62. public class JsonList implements JsonObj {
private final List<JsonObj> items;
public JsonString(JsonObj... items) {
this.items = asList(items);
}
public String toJson() {
return "[" + items.stream()
.map(item ­> item.toJson())
.collect(joining(",")) + "]";
}
}

63. JsonObj obj = new JsonList(
new JsonString("a"),
new JsonList(
new JsonString("b"),
new JsonString("c")
),
new JsonString("d")
);
System.out.println(obj.toJson());
// ["a",["b","c"],"d"]

64. (limitations)
Subtyping is coupled to implementation

65. (limitations)
Subtyping is coupled to implementation
... cannot extend existing types

66. (limitations)
Subtyping is coupled to implementation
... cannot extend existing types
... need wrapper classes

67. Too constraining!

68. (clojure protocols)
dispatch on the type of first argument

69. (defprotocol Json
(to­json [this]))

70. (extend­type String Json
(to­json [this]
(str """ this """)))
(extend­type List Json
(to­json [this]
(str "[" (str/join "," (map to­json this)) "]")))
(extend­type nil Json
(to­json [this]
"null"))

71. (to­json ["a" ["b" "c"] nil "d"])
;;=> ["a",["b","c"],null,"d"]

72. Why stop there?

73. (clojure multimethods)
dispatch on anything!

74. (defmulti greet :country)
(defmethod greet "PL" [person]
(println "Dzień dobry," (:name person)))
(defmethod greet "FR" [person]
(println "Bonjour," (:name person) "!"))
(defmethod greet :default [person]
(println "Hello," (:name person)))
(greet {:name "Jacques" :country "FR"})
;;=> Bonjour, Jacques !

75. (state management)

76. State Machine / Business Process / Entity

77. "Class" as a namespace
(def Account
{'deposit (fn [state amount]
(update state :balance + amount))
'withdraw (fn [state amount]
(if (< amount (state :balance))
(update state :balance ­ amount)
state))})
(def state0 {:balance 0})
(def state1 ((Account 'deposit) state0 100))
(def state2 ((Account 'withdraw) state1 30))
(def state3 ((Account 'withdraw) state2 20))

78. Partially apply state with "constructor"
(defn new­object [clazz initial­state]
..........
..........
..........)
(def acc (new­object Account {:balance 0}))
(acc 'deposit 100)
(acc 'withdraw 30)
(acc 'withdraw 20)

79. Partially apply state with "constructor"
(defn new­object [clazz initial­state]
(let [state­ref (atom initial­state)]
..........
..........))
(def acc (new­object Account {:balance 0}))
(acc 'deposit 100)
(acc 'withdraw 30)
(acc 'withdraw 20)

80. Partially apply state with "constructor"
(defn new­object [clazz initial­state]
(let [state­ref (atom initial­state)]
(fn [method & args]
..........)))
(def acc (new­object Account {:balance 0}))
(acc 'deposit 100)
(acc 'withdraw 30)
(acc 'withdraw 20)

81. Partially apply state with "constructor"
(defn new­object [clazz initial­state]
(let [state­ref (atom initial­state)]
(fn [method & args]
(apply swap! state­ref (clazz method) args))))
(def acc (new­object Account {:balance 0}))
(acc 'deposit 100)
(acc 'withdraw 30)
(acc 'withdraw 20)

82. (the takeaway)
Eierlegende Wollmilchsau

83. (the takeaway)
Object

84. (google "Clojure Made Simple")
(questions? "Osvaldas Grigas" @ogrigas)