Clojure Lisp for the Real #clojure

Transcription

1 Clojure Lisp for the Real #clojure 1

2 Bullet Points Values Code is data Generic data access Concurrency 2

3 Stuart Sierra Relevance, Inc. Clojure/core Clojure contributor 3

4 Values 4

5 Values 3 5

6 Values = 5 6

7 Values let x = 3 7

8 Values let x = 3 let x = 5 8

9 Values let 3 = 5 9

10 Values define 3 = 5 10

11 Values 3 11

12 Values Immutable 3 12

13 Values Immutable 3 Persistent 13

14 " He llo, world! " 14

15 char greeting[14]; strcpy(greeting, "Hello, World!"); greeting H e l l o, w o r l d! \0 15

16 char* name = greeting + 7; greeting name H e l l o, w o r l d! \0 16

17 name[7] = 'b'; name[10] = 'e'; greeting name H e l l o, b o r e d! \0 17

18 String greeting = new String("Hello, world!"); greeting java.lang.string H e l l o, w o r l d! 18

19 String alt = greeting.replace("world", "bored"); greeting java.lang.string H e l l o, w o r l d! alt java.lang.string H e l l o, b o r e d! 19

20 greeting java.lang.string H e l l o, w o r l d! Immutable 20

21 In the real world, values don't change. 21

22 Clojure Values 3 Long 6.022e23 Double "Hello, world!" String 3.0M BigDecimal N BigInt 2/3 Ratio 22

23 Clojure Values even? :last-name (print 99 "bottles") Symbol Keyword List [3.14 :pi] Vector {:x 3 "y" 4} Map #{7 9 "foo"} Set 23

24 Clojure Values Immutable Persistent 24

25 String alt = greeting.replace("world", "bored"); greeting java.lang.string H e l l o, w o r l d! alt java.lang.string H e l l o, b o r e d! 25

26 Clojure Values List O(1) at the head O(n) anywhere else Vector O(log32n) access Map O(log32n) access Set O(log32n) contains? 26

27

28 32 1 = = = 32, = 1,048, = 33,554, = 1,073,741, = 34,359,738,368 28

29 log < 2 log32 10,000 < 3 log32 1,000,000 < 4 log32 10,000,000 < 5 log32 1,000,000,000 < 6 29

30 In the real world, log32n is fast enough. 30

31 Code is Data 31

32 Code is Data #{ {:first "Stuart" :last "Sierra"} {:first "Luke" :last "VanderHart"} {:first "Michael" :last "Fogus"} } 32

33 Code is Data #{ {:first "Stuart" :last "Sierra"} {:first "Luke" :last "VanderHart"} {:first "Michael" :last "Fogus"} } A set of maps 33

34 Symbol List ( ) 34

35 Symbol List ( ) Function call 35

36 Symbols Symbols List Vector Function call (defn average [& nums] (/ (reduce + nums) (count nums))) (average 3 4 5) 36

37 Host Interop. constructor (def m (ConcurrentHashMap. 100)) (.put m "key" "value") method call 37

38 You Characters Lexer/Parser Abstract Syntax Tree Compiler/ Interpreter 38

39 You Characters Clojure Reader Data Structures Clojure Compiler 39

40 You Characters Clojure Reader Macros Data Structures Clojure Compiler 40

41 (let [file...initializer...] (try... do something... (finally (.close file)))) 41

42 (defmacro with-open [bindings & body] `(let ~bindings (try (finally (.close ~(first bindings))))) 42

43 (let [file...initializer...] (try... do something... (finally (.close file)))) 43

44 (with-open [file...initializer...]... do something...) 44

45 Generic data access 45

46 Generic data access #{ {:first "Stuart" :last "Sierra"} {:first "Luke" :last "VanderHart"} {:first "Michael" :last "Fogus"} } A set of maps 46

47 Author[] authors =... String names[] = new names[authors.length]; for (int i = 0; i < authors.length; i++) { names[i] = authors[i].getfirstname(); } 47

48 (defn get-first-name [author] (get author :first)) (map get-first-name authors) ("Stuart" "Luke" "Michael") Higher-order function 48

49 Anonymous function (map (fn [a] (get a :first)) authors) ("Stuart" "Luke" "Michael") 49

50 Anonymous function (map #(get % :first) authors) ("Stuart" "Luke" "Michael") 50

51 Maps are functions (map #(% :first) authors) ("Stuart" "Luke" "Michael") 51

52 Keywords are functions! (map #(:first %) authors) ("Stuart" "Luke" "Michael") 52

53 Keywords are functions (map :first authors) ("Stuart" "Luke" "Michael") 53

54 String names[] = new names[authors.length]; for (int i = 0; i < authors.length; i++) { names[i] = authors[i].getname(); } vs. (map :first authors) 54

55 (map function set-of-maps) 55

56 (map function map-of-maps) (map function list-of-vectors) (map function vector-of-sets-of-maps) (map function set-of-maps) 56

57 (map function map-of-maps) (map function list-of-vectors) (map function vector-of-sets-of-maps) (map function set-of-maps) (map function (file-seq directory)) (map function (line-seq file)) (map function (xml-seq xml-tree)) (map function (resultset-seq query)) 57

58 Sequence API Sequence Generators map filter reduce count some remove replace and lots more... List Vector Map ResultSet Stream Directory Iterator XML and lots more... 58

59 Polymorphism 59

60 Object-Oriented, The Good Parts 60

61 dispatch function method method multimethod method method method 61

62 method protocol method method method Protocol method protocol method method method 62

63 Existing Interfaces Your new protocol here Existing Types Existing Method Implementations Your new type here and here! 63

64 The Expression Problem Sierra "Solving the Expression Problem with Clojure 1.2" IBM DeveloperWorks Chris Houser "Clojure's Solutions to the Expression Problem" Strange Loop

65 Concurrency 65

66 Parallelism Concurrency State 66

67 class Invoice { private Date date; public Date getdate() { } return this.date; } public void setdate(date date) { } this.date = date; 67

68 class Date { public void setday(int day); public void setmonth(int month); public void setyear(int year); } Mutable! 68

69 class Invoice { private Date date; public Date getdate() { } return this.date; public void setdate(date date) { this.date = date; } } Better not change it! 69

70 class Invoice { private Date date; public Date getdate() { return this.date; Better not change it! } public void setdate(date date) { } this.date = date; } Better not change it! 70

71 Programming with immutable values means never having to say you're sorry. 71

72 today July 25 72

73 today July 25 July 26 73

74 Identity today State July 25 Value July 26 Value 74

75 Identity today State July 25 function July 26 Value Value 75

76 Identity today State July 24 function July 25 function July 26 Past Present Future 76

77 Identity today State July 24 function July 25 function July 26 Past Present Future The future is a function of the past. 77

78 Mutable References Ref Atom Var Agent 78

79 readers writer Atom writer retry abort 79

80 Atom (def tick (atom 1)) 1 (deref tick) 1 tick 80

81 Atom (def tick (atom 1)) (deref tick) 1 (swap! tick 2 tick 1 inc 2 81

82 Atom (def tick (atom 1)) (deref tick) 1 (swap! tick 2 (swap! tick + 12 tick

83 value value value value identity value value value value identity identity value value value value 83

84 value value value value identity value value value value identity identity value value value value 84

85 readers Ref writer writer transaction retry abort Ref 85

86 Ref (def A (ref 1)) (def B (ref 10)) A 1 B 10 86

87 Ref (def A (ref 1)) (def B (ref 10)) (dosync (alter A inc) (alter B + 10)) A 1 B inc 2 transaction 87

88 Ref (def A (ref 1)) (def B (ref 10)) (dosync (alter A inc) (alter B A B

89 Database Transactions Atomic Consistent Isolated Durable 89

90 Clojure Transactions Atomic Consistent Isolated 90

91 readers action queue action action Agent Agent Thread Pool 91

92 Agent (def A (agent 1)) queue A 1 92

93 Agent (def A (agent 1)) (send A 1 queue inc A 1 93

94 Agent (def A (agent 1)) (send A 1 queue A

95 other threads Var root binding binding threadlocal threadlocal binding 95

96 Concurrency Ref Atom Var Agent 96

97 In the real world, JavaScript is everywhere 97

98 ClojureScript 98

99 More Clojure: clojure.org Clojure/core: clojure.com Me: Image Credits openclipart.org pdtextures.blogspot.com Clojure logo by Tom Hickey 99