You have achieved clojure enlightenment. Namaste.
This commit is contained in:
J. Fernando Sánchez
parent
809af93e35
commit
8ce6e37c49
@ -3,37 +3,38 @@
|
||||
|
||||
(meditations
|
||||
"We shall contemplate truth by testing reality, via equality"
|
||||
(= __ true)
|
||||
(= true true)
|
||||
|
||||
"To understand reality, we must compare our expectations against reality"
|
||||
(= __ (+ 1 1))
|
||||
(= 2 (+ 1 1))
|
||||
|
||||
"You can test equality of many things"
|
||||
(= (+ 3 4) 7 (+ 2 __))
|
||||
(= (+ 3 4) 7 (+ 2 5))
|
||||
|
||||
"Some things may appear different, but be the same"
|
||||
(= __ (= 2 2/1))
|
||||
(= true (= 2 2/1))
|
||||
|
||||
"You cannot generally float to heavens of integers"
|
||||
(= __ (= 2 2.0))
|
||||
(= false (= 2 2.0))
|
||||
|
||||
"But a looser equality is also possible"
|
||||
(= __ (== 2.0 2))
|
||||
(= true (== 2.0 2))
|
||||
|
||||
"Something is not equal to nothing"
|
||||
(= __ (not (= 1 nil)))
|
||||
(= true (not (= 1 nil)))
|
||||
|
||||
"Strings, and keywords, and symbols: oh my!"
|
||||
(= __ (= "hello" :hello 'hello))
|
||||
(= false (= "hello" :hello 'hello))
|
||||
|
||||
"Make a keyword with your keyboard"
|
||||
(= :hello (keyword __))
|
||||
(= :hello (keyword "hello"))
|
||||
|
||||
"Symbolism is all around us"
|
||||
(= 'hello (symbol __))
|
||||
(= 'hello (symbol "hello"))
|
||||
|
||||
"What could be equivalent to nothing?"
|
||||
(= __ nil)
|
||||
(= nil nil)
|
||||
|
||||
"When things cannot be equal, they must be different"
|
||||
(not= :fill-in-the-blank __))
|
||||
(not= :fill-in-the-blank "fill in the blank"))
|
||||
|
||||
|
||||
@ -4,67 +4,67 @@
|
||||
|
||||
(meditations
|
||||
"A string is nothing more than text surrounded by double quotes"
|
||||
(= __ "hello")
|
||||
(= "hello" "hello")
|
||||
|
||||
"But double quotes are just magic on top of something deeper"
|
||||
(= __ (str 'world))
|
||||
(= "world" (str 'world))
|
||||
|
||||
"You can do more than create strings, you can put them together"
|
||||
(= "Cool right?" (str __ __))
|
||||
(= "Cool right?" (str "Cool " "right?"))
|
||||
|
||||
"You can even get certain characters"
|
||||
(= \C (get "Characters" __))
|
||||
(= \C (get "Characters" 0))
|
||||
|
||||
"Or even count the characters"
|
||||
(= __ (count "Hello World"))
|
||||
(= 11 (count "Hello World"))
|
||||
|
||||
"But strings and characters are not the same"
|
||||
(= __ (= \c "c"))
|
||||
(= false (= \c "c"))
|
||||
|
||||
"What if you only wanted to get part of a string?"
|
||||
(= "World" (subs "Hello World" __ __))
|
||||
(= "World" (subs "Hello World" 6 11))
|
||||
|
||||
"How about joining together elements in a list?"
|
||||
(= __ (string/join '(1 2 3)))
|
||||
(= "123" (string/join '(1 2 3)))
|
||||
|
||||
"What if you wanted to separate them out?"
|
||||
(= "1, 2, 3" (string/join __ '(1 2 3)))
|
||||
(= "1, 2, 3" (string/join ", " '(1 2 3)))
|
||||
|
||||
"Maybe you want to separate out all your lines"
|
||||
(= [__ __ __] (string/split-lines "1\n2\n3"))
|
||||
(= [ "1" "2" "3" ] (string/split-lines "1\n2\n3"))
|
||||
|
||||
"You may want to make sure your words are backwards"
|
||||
(= __ (string/reverse "hello"))
|
||||
(= "olleh" (string/reverse "hello"))
|
||||
|
||||
"Maybe you want to find the index of the first occurrence of a substring"
|
||||
(= 0 (string/index-of "hello world" __))
|
||||
(= 0 (string/index-of "hello world" "h"))
|
||||
|
||||
"Or maybe the last index of the same"
|
||||
(= __ (string/last-index-of "hello world, hello" "hello"))
|
||||
(= 13 (string/last-index-of "hello world, hello" "hello"))
|
||||
|
||||
"But when something doesn't exist, nothing is found"
|
||||
(= __ (string/index-of "hello world" "bob"))
|
||||
(= nil (string/index-of "hello world" "bob"))
|
||||
|
||||
"Sometimes you don't want whitespace cluttering the front and back"
|
||||
(= __ (string/trim " \nhello world \t \n"))
|
||||
(= "hello world" (string/trim " \nhello world \t \n"))
|
||||
|
||||
"You can check if something is a char"
|
||||
(= __ (char? \c))
|
||||
(= true (char? \c))
|
||||
|
||||
"But it may not be"
|
||||
(= __ (char? "a"))
|
||||
(= false (char? "a"))
|
||||
|
||||
"But chars aren't strings"
|
||||
(= __ (string? \b))
|
||||
(= false (string? \b))
|
||||
|
||||
"Strings are strings"
|
||||
(= true (string? __))
|
||||
(= true (string? "b"))
|
||||
|
||||
"Some strings may be blank"
|
||||
(= __ (string/blank? ""))
|
||||
(= true (string/blank? ""))
|
||||
|
||||
"Even if at first glance they aren't"
|
||||
(= __ (string/blank? " \n \t "))
|
||||
(= true (string/blank? " \n \t "))
|
||||
|
||||
"However, most strings aren't blank"
|
||||
(= __ (string/blank? "hello?\nare you out there?")))
|
||||
(= false (string/blank? "hello?\nare you out there?")))
|
||||
|
||||
@ -3,43 +3,43 @@
|
||||
|
||||
(meditations
|
||||
"Lists can be expressed by function or a quoted form"
|
||||
(= '(__ __ __ __ __) (list 1 2 3 4 5))
|
||||
(= '(1 2 3 4 5) (list 1 2 3 4 5))
|
||||
|
||||
"They are Clojure seqs (sequences), so they allow access to the first"
|
||||
(= __ (first '(1 2 3 4 5)))
|
||||
(= 1 (first '(1 2 3 4 5)))
|
||||
|
||||
"As well as the rest"
|
||||
(= __ (rest '(1 2 3 4 5)))
|
||||
(= '(2 3 4 5) (rest '(1 2 3 4 5)))
|
||||
|
||||
"Count your blessings"
|
||||
(= __ (count '(dracula dooku chocula)))
|
||||
(= 3 (count '(dracula dooku chocula)))
|
||||
|
||||
"Before they are gone"
|
||||
(= __ (count '()))
|
||||
(= 0 (count '()))
|
||||
|
||||
"The rest, when nothing is left, is empty"
|
||||
(= __ (rest '(100)))
|
||||
(= '() (rest '(100)))
|
||||
|
||||
"Construction by adding an element to the front is easy"
|
||||
(= __ (cons :a '(:b :c :d :e)))
|
||||
(= '(:a :b :c :d :e) (cons :a '(:b :c :d :e)))
|
||||
|
||||
"Conjoining an element to a list isn't hard either"
|
||||
(= __ (conj '(:a :b :c :d) :e))
|
||||
(= '(:e :a :b :c :d) (conj '(:a :b :c :d) :e))
|
||||
|
||||
"You can use a list like a stack to get the first element"
|
||||
(= __ (peek '(:a :b :c :d :e)))
|
||||
(= :a (peek '(:a :b :c :d :e)))
|
||||
|
||||
"Or the others"
|
||||
(= __ (pop '(:a :b :c :d :e)))
|
||||
(= '(:b :c :d :e) (pop '(:a :b :c :d :e)))
|
||||
|
||||
"But watch out if you try to pop nothing"
|
||||
(= __ (try
|
||||
(= "No dice!" (try
|
||||
(pop '())
|
||||
(catch IllegalStateException e
|
||||
"No dice!")))
|
||||
|
||||
"The rest of nothing isn't so strict"
|
||||
(= __ (try
|
||||
(= '() (try
|
||||
(rest '())
|
||||
(catch IllegalStateException e
|
||||
"No dice!"))))
|
||||
|
||||
@ -3,31 +3,32 @@
|
||||
|
||||
(meditations
|
||||
"You can use vectors in clojure as array-like structures"
|
||||
(= __ (count [42]))
|
||||
(= 1 (count [42]))
|
||||
|
||||
"You can create a vector from a list"
|
||||
(= __ (vec '(1)))
|
||||
(= [1] (vec '(1)))
|
||||
|
||||
"Or from some elements"
|
||||
(= __ (vector nil nil))
|
||||
(= [nil nil] (vector nil nil))
|
||||
|
||||
"But you can populate it with any number of elements at once"
|
||||
(= [1 __] (vec '(1 2)))
|
||||
(= [1 2] (vec '(1 2)))
|
||||
|
||||
"Conjoining to a vector is different than to a list"
|
||||
(= __ (conj [111 222] 333))
|
||||
(= [111 222 333] (conj [111 222] 333))
|
||||
|
||||
"You can get the first element of a vector like so"
|
||||
(= __ (first [:peanut :butter :and :jelly]))
|
||||
(= :peanut (first [:peanut :butter :and :jelly]))
|
||||
|
||||
"And the last in a similar fashion"
|
||||
(= __ (last [:peanut :butter :and :jelly]))
|
||||
(= :jelly (last [:peanut :butter :and :jelly]))
|
||||
|
||||
"Or any index if you wish"
|
||||
(= __ (nth [:peanut :butter :and :jelly] 3))
|
||||
(= :jelly (nth [:peanut :butter :and :jelly] 3))
|
||||
|
||||
"You can also slice a vector"
|
||||
(= __ (subvec [:peanut :butter :and :jelly] 1 3))
|
||||
(= [:butter :and] (subvec [:peanut :butter :and :jelly] 1 3))
|
||||
|
||||
"Equality with collections is in terms of values"
|
||||
(= (list 1 2 3) (vector 1 2 __)))
|
||||
(= (list 1 2 3) (vector 1 2 3)))
|
||||
|
||||
|
||||
@ -4,19 +4,19 @@
|
||||
|
||||
(meditations
|
||||
"You can create a set by converting another collection"
|
||||
(= #{3} (set __))
|
||||
(= #{3} (set '(3)))
|
||||
|
||||
"Counting them is like counting other collections"
|
||||
(= __ (count #{1 2 3}))
|
||||
(= 3 (count #{1 2 3}))
|
||||
|
||||
"Remember that a set is a *mathematical* set"
|
||||
(= __ (set '(1 1 2 2 3 3 4 4 5 5)))
|
||||
(= #{1 2 3 4 5} (set '(1 1 2 2 3 3 4 4 5 5)))
|
||||
|
||||
"You can ask clojure for the union of two sets"
|
||||
(= __ (set/union #{1 2 3 4} #{2 3 5}))
|
||||
(= #{1 2 3 4 5} (set/union #{1 2 3 4} #{2 3 5}))
|
||||
|
||||
"And also the intersection"
|
||||
(= __ (set/intersection #{1 2 3 4} #{2 3 5}))
|
||||
(= #{2 3} (set/intersection #{1 2 3 4} #{2 3 5}))
|
||||
|
||||
"But don't forget about the difference"
|
||||
(= __ (set/difference #{1 2 3 4 5} #{2 3 5})))
|
||||
(= #{1 4} (set/difference #{1 2 3 4 5} #{2 3 5})))
|
||||
|
||||
@ -3,60 +3,60 @@
|
||||
|
||||
(meditations
|
||||
"Don't get lost when creating a map"
|
||||
(= {:a 1 :b 2} (hash-map :a 1 __ __))
|
||||
(= {:a 1 :b 2} (hash-map :a 1 :b 2))
|
||||
|
||||
"A value must be supplied for each key"
|
||||
(= {:a 1} (hash-map :a __))
|
||||
(= {:a 1} (hash-map :a 1))
|
||||
|
||||
"The size is the number of entries"
|
||||
(= __ (count {:a 1 :b 2}))
|
||||
(= 2 (count {:a 1 :b 2}))
|
||||
|
||||
"You can look up the value for a given key"
|
||||
(= __ (get {:a 1 :b 2} :b))
|
||||
(= 2 (get {:a 1 :b 2} :b))
|
||||
|
||||
"Maps can be used as functions to do lookups"
|
||||
(= __ ({:a 1 :b 2} :a))
|
||||
(= 1 ({:a 1 :b 2} :a))
|
||||
|
||||
"And so can keywords"
|
||||
(= __ (:a {:a 1 :b 2}))
|
||||
(= 1 (:a {:a 1 :b 2}))
|
||||
|
||||
"But map keys need not be keywords"
|
||||
(= __ ({2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"} 2014))
|
||||
(= "Sochi" ({2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"} 2014))
|
||||
|
||||
"You may not be able to find an entry for a key"
|
||||
(= __ (get {:a 1 :b 2} :c))
|
||||
(= nil (get {:a 1 :b 2} :c))
|
||||
|
||||
"But you can provide your own default"
|
||||
(= __ (get {:a 1 :b 2} :c :key-not-found))
|
||||
(= :key-not-found (get {:a 1 :b 2} :c :key-not-found))
|
||||
|
||||
"You can find out if a key is present"
|
||||
(= __ (contains? {:a nil :b nil} :b))
|
||||
(= true (contains? {:a nil :b nil} :b))
|
||||
|
||||
"Or if it is missing"
|
||||
(= __ (contains? {:a nil :b nil} :c))
|
||||
(= false (contains? {:a nil :b nil} :c))
|
||||
|
||||
"Maps are immutable, but you can create a new and improved version"
|
||||
(= {1 "January" 2 __} (assoc {1 "January"} 2 "February"))
|
||||
(= {1 "January" 2 "February"} (assoc {1 "January"} 2 "February"))
|
||||
|
||||
"You can also create a new version with an entry removed"
|
||||
(= {__ __} (dissoc {1 "January" 2 "February"} 2))
|
||||
(= {1 "January"} (dissoc {1 "January" 2 "February"} 2))
|
||||
|
||||
"Create a new map by merging"
|
||||
(= {:a 1 :b 2 __ __} (merge {:a 1 :b 2} {:c 3}))
|
||||
(= {:a 1 :b 2 :c 3} (merge {:a 1 :b 2} {:c 3}))
|
||||
|
||||
"Specify how to handle entries with same keys when merging"
|
||||
(= {:a 1 :b __ :c 3} (merge-with + {:a 1 :b 1} {:b 1 :c 3}))
|
||||
(= {:a 1 :b 2 :c 3} (merge-with + {:a 1 :b 1} {:b 1 :c 3}))
|
||||
|
||||
"Often you will need to get the keys, but the order is undependable"
|
||||
(= (list __ __ __)
|
||||
(= (list 2010 2014 2018)
|
||||
(sort (keys { 2014 "Sochi" 2018 "PyeongChang" 2010 "Vancouver"})))
|
||||
|
||||
"You can get the values in a similar way"
|
||||
(= (list __ __ __)
|
||||
(= (list "PyeongChang" "Sochi" "Vancouver")
|
||||
(sort (vals {2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"})))
|
||||
|
||||
"You can even iterate over the map entries as a seq"
|
||||
(= {:a __ :b __}
|
||||
(= {:a 2 :b 3}
|
||||
(into {}
|
||||
(map
|
||||
(fn [[k v]] [k (inc v)])
|
||||
|
||||
@ -8,33 +8,33 @@
|
||||
|
||||
(meditations
|
||||
"Calling a function is like giving it a hug with parentheses"
|
||||
(= __ (square 9))
|
||||
(= 81 (square 9))
|
||||
|
||||
"Functions are usually defined before they are used"
|
||||
(= __ (multiply-by-ten 2))
|
||||
(= 20 (multiply-by-ten 2))
|
||||
|
||||
"But they can also be defined inline"
|
||||
(= __ ((fn [n] (* 5 n)) 2))
|
||||
(= 10 ((fn [n] (* 5 n)) 2))
|
||||
|
||||
"Or using an even shorter syntax"
|
||||
(= __ (#(* 15 %) 4))
|
||||
(= 60 (#(* 15 %) 4))
|
||||
|
||||
"Even anonymous functions may take multiple arguments"
|
||||
(= __ (#(+ %1 %2 %3) 4 5 6))
|
||||
(= 15 (#(+ %1 %2 %3) 4 5 6))
|
||||
|
||||
"Arguments can also be skipped"
|
||||
(= __ (#(str "AA" %2) "bb" "CC"))
|
||||
(= "AACC" (#(str "AA" %2) "bb" "CC"))
|
||||
|
||||
"One function can beget another"
|
||||
(= 9 (((fn [] ___)) 4 5))
|
||||
(= 9 (((fn [] +)) 4 5))
|
||||
|
||||
"Functions can also take other functions as input"
|
||||
(= 20 ((fn [f] (f 4 5))
|
||||
___))
|
||||
*))
|
||||
|
||||
"Higher-order functions take function arguments"
|
||||
(= 25 (___
|
||||
(= 25 ( #(% 5)
|
||||
(fn [n] (* n n))))
|
||||
|
||||
"But they are often better written using the names of functions"
|
||||
(= 25 (___ square)))
|
||||
(= 25 ( #(% 5) square)))
|
||||
|
||||
@ -10,38 +10,38 @@
|
||||
|
||||
(meditations
|
||||
"You will face many decisions"
|
||||
(= __ (if (false? (= 4 5))
|
||||
(= :a (if (false? (= 4 5))
|
||||
:a
|
||||
:b))
|
||||
|
||||
"Some of them leave you no alternative"
|
||||
(= __ (if (> 4 3)
|
||||
(= [] (if (> 4 3)
|
||||
[]))
|
||||
|
||||
"And in such a situation you may have nothing"
|
||||
(= __ (if (nil? 0)
|
||||
(= nil (if (nil? 0)
|
||||
[:a :b :c]))
|
||||
|
||||
"In others your alternative may be interesting"
|
||||
(= :glory (if (not (empty? ()))
|
||||
:doom
|
||||
__))
|
||||
:glory))
|
||||
|
||||
"You may have a multitude of possible paths"
|
||||
(let [x 5]
|
||||
(= :your-road (cond (= x __) :road-not-taken
|
||||
(= x __) :another-road-not-taken
|
||||
:else __)))
|
||||
(= :your-road (cond (= x 1) :road-not-taken
|
||||
(= x 2) :another-road-not-taken
|
||||
:else :your-road)))
|
||||
|
||||
"Or your fate may be sealed"
|
||||
(= 'doom (if-not (zero? __)
|
||||
(= 'doom (if-not (zero? 10)
|
||||
'doom
|
||||
'more-doom))
|
||||
|
||||
"In case of emergency, go fast"
|
||||
(= "pretty fast"
|
||||
(explain-exercise-velocity __))
|
||||
(explain-exercise-velocity :bicycling))
|
||||
|
||||
"But admit it when you don't know what to do"
|
||||
(= __
|
||||
(= "is that even exercise?"
|
||||
(explain-exercise-velocity :watching-tv)))
|
||||
|
||||
@ -3,33 +3,33 @@
|
||||
|
||||
(meditations
|
||||
"The map function relates a sequence to another"
|
||||
(= [__ __ __] (map (fn [x] (* 4 x)) [1 2 3]))
|
||||
(= [4 8 12] (map (fn [x] (* 4 x)) [1 2 3]))
|
||||
|
||||
"You may create that mapping"
|
||||
(= [1 4 9 16 25] (map (fn [x] __) [1 2 3 4 5]))
|
||||
(= [1 4 9 16 25] (map (fn [x] (* x x)) [1 2 3 4 5]))
|
||||
|
||||
"Or use the names of existing functions"
|
||||
(= __ (map nil? [:a :b nil :c :d]))
|
||||
(= [false false true false false] (map nil? [:a :b nil :c :d]))
|
||||
|
||||
"A filter can be strong"
|
||||
(= __ (filter (fn [x] false) '(:anything :goes :here)))
|
||||
(= '() (filter (fn [x] false) '(:anything :goes :here)))
|
||||
|
||||
"Or very weak"
|
||||
(= __ (filter (fn [x] true) '(:anything :goes :here)))
|
||||
(= '(:anything :goes :here) (filter (fn [x] true) '(:anything :goes :here)))
|
||||
|
||||
"Or somewhere in between"
|
||||
(= [10 20 30] (filter (fn [x] __) [10 20 30 40 50 60 70 80]))
|
||||
(= [10 20 30] (filter (fn [x] (< x 40)) [10 20 30 40 50 60 70 80]))
|
||||
|
||||
"Maps and filters may be combined"
|
||||
(= [10 20 30] (map (fn [x] __) (filter (fn [x] __) [1 2 3 4 5 6 7 8])))
|
||||
(= [10 20 30] (map (fn [x] (* x 10)) (filter (fn [x] (< x 4)) [1 2 3 4 5 6 7 8])))
|
||||
|
||||
"Reducing can increase the result"
|
||||
(= __ (reduce (fn [a b] (* a b)) [1 2 3 4]))
|
||||
(= 24 (reduce (fn [a b] (* a b)) [1 2 3 4]))
|
||||
|
||||
"You can start somewhere else"
|
||||
(= 2400 (reduce (fn [a b] (* a b)) __ [1 2 3 4]))
|
||||
(= 2400 (reduce (fn [a b] (* a b)) 100 [1 2 3 4]))
|
||||
|
||||
"Numbers are not the only things one can reduce"
|
||||
(= "longest" (reduce (fn [a b]
|
||||
(if (< __ __) b a))
|
||||
(if (< (count a) (count b)) b a))
|
||||
["which" "word" "is" "longest"])))
|
||||
|
||||
@ -10,19 +10,19 @@
|
||||
"!")))
|
||||
|
||||
(defmulti diet (fn [x] (:eater x)))
|
||||
(defmethod diet :herbivore [a] __)
|
||||
(defmethod diet :carnivore [a] __)
|
||||
(defmethod diet :default [a] __)
|
||||
(defmethod diet :herbivore [a] (str (:name a) " eats veggies."))
|
||||
(defmethod diet :carnivore [a] (str (:name a) " eats animals."))
|
||||
(defmethod diet :default [a] (str "I don't know what " (:name a) " eats."))
|
||||
|
||||
(meditations
|
||||
"Some functions can be used in different ways - with no arguments"
|
||||
(= __ (hello))
|
||||
(= "Hello World!" (hello))
|
||||
|
||||
"With one argument"
|
||||
(= __ (hello "world"))
|
||||
(= "Hello, you silly world." (hello "world"))
|
||||
|
||||
"Or with many arguments"
|
||||
(= __
|
||||
(= "Hello to this group: Peter, Paul, Mary!"
|
||||
(hello "Peter" "Paul" "Mary"))
|
||||
|
||||
"Multimethods allow more complex dispatching"
|
||||
|
||||
@ -3,26 +3,26 @@
|
||||
|
||||
(meditations
|
||||
"There are many ways to generate a sequence"
|
||||
(= __ (range 1 5))
|
||||
(= '(1 2 3 4) (range 1 5))
|
||||
|
||||
"The range starts at the beginning by default"
|
||||
(= __ (range 5))
|
||||
(= '(0 1 2 3 4) (range 5))
|
||||
|
||||
"Only take what you need when the sequence is large"
|
||||
(= [0 1 2 3 4 5 6 7 8 9]
|
||||
(take __ (range 100)))
|
||||
(take 10 (range 100)))
|
||||
|
||||
"Or limit results by dropping what you don't need"
|
||||
(= [95 96 97 98 99]
|
||||
(drop __ (range 100)))
|
||||
(drop 95 (range 100)))
|
||||
|
||||
"Iteration provides an infinite lazy sequence"
|
||||
(= __ (take 8 (iterate (fn [x] (* x 2)) 1)))
|
||||
(= '(1 2 4 8 16 32 64 128) (take 8 (iterate (fn [x] (* x 2)) 1)))
|
||||
|
||||
"Repetition is key"
|
||||
(= [:a :a :a :a :a :a :a :a :a :a]
|
||||
(repeat 10 __))
|
||||
(repeat 10 :a))
|
||||
|
||||
"Iteration can be used for repetition"
|
||||
(= (repeat 100 "hello")
|
||||
(take 100 (iterate ___ "hello"))))
|
||||
(take 100 (iterate #(str %) "hello"))))
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
|
||||
(meditations
|
||||
"Sequence comprehensions can bind each element in turn to a symbol"
|
||||
(= __
|
||||
(= '( 0 1 2 3 4 5 )
|
||||
(for [x (range 6)]
|
||||
x))
|
||||
|
||||
@ -12,20 +12,20 @@
|
||||
(map (fn [x] (* x x))
|
||||
(range 6))
|
||||
(for [x (range 6)]
|
||||
__))
|
||||
(* x x)))
|
||||
|
||||
"And also filtering"
|
||||
(= '(1 3 5 7 9)
|
||||
(filter odd? (range 10))
|
||||
(for [x __ :when (odd? x)]
|
||||
(for [x (range 10) :when (odd? x)]
|
||||
x))
|
||||
|
||||
"Combinations of these transformations is trivial"
|
||||
(= '(1 9 25 49 81)
|
||||
(map (fn [x] (* x x))
|
||||
(filter odd? (range 10)))
|
||||
(for [x (range 10) :when __]
|
||||
__))
|
||||
(for [x (range 10) :when (odd? x)]
|
||||
(* x x)))
|
||||
|
||||
"More complex transformations simply take multiple binding forms"
|
||||
(= [[:top :left] [:top :middle] [:top :right]
|
||||
@ -33,4 +33,4 @@
|
||||
[:bottom :left] [:bottom :middle] [:bottom :right]]
|
||||
(for [row [:top :middle :bottom]
|
||||
column [:left :middle :right]]
|
||||
__)))
|
||||
[row column])))
|
||||
|
||||
@ -5,31 +5,31 @@
|
||||
|
||||
(meditations
|
||||
"One may know what they seek by knowing what they do not seek"
|
||||
(= [__ __ __] (let [not-a-symbol? (complement symbol?)]
|
||||
(= [true false true] (let [not-a-symbol? (complement symbol?)]
|
||||
(map not-a-symbol? [:a 'b "c"])))
|
||||
|
||||
"Praise and 'complement' may help you separate the wheat from the chaff"
|
||||
(= [:wheat "wheat" 'wheat]
|
||||
(let [not-nil? ___]
|
||||
(let [not-nil? (complement nil?)]
|
||||
(filter not-nil? [nil :wheat nil "wheat" nil 'wheat nil])))
|
||||
|
||||
"Partial functions allow procrastination"
|
||||
(= 20 (let [multiply-by-5 (partial * 5)]
|
||||
(___ __)))
|
||||
(multiply-by-5 4)))
|
||||
|
||||
"Don't forget: first things first"
|
||||
(= [__ __ __ __]
|
||||
(= [:a :b :c :d]
|
||||
(let [ab-adder (partial concat [:a :b])]
|
||||
(ab-adder [__ __])))
|
||||
(ab-adder [:c :d])))
|
||||
|
||||
"Functions can join forces as one 'composed' function"
|
||||
(= 25 (let [inc-and-square (comp square inc)]
|
||||
(inc-and-square __)))
|
||||
(inc-and-square 4)))
|
||||
|
||||
"Have a go on a double dec-er"
|
||||
(= __ (let [double-dec (comp dec dec)]
|
||||
(= 8 (let [double-dec (comp dec dec)]
|
||||
(double-dec 10)))
|
||||
|
||||
"Be careful about the order in which you mix your functions"
|
||||
(= 99 (let [square-and-dec ___]
|
||||
(= 99 (let [square-and-dec (comp dec square)]
|
||||
(square-and-dec 10))))
|
||||
|
||||
@ -3,21 +3,28 @@
|
||||
|
||||
(defn is-even? [n]
|
||||
(if (= n 0)
|
||||
__
|
||||
(___ (is-even? (dec n)))))
|
||||
true
|
||||
(not (is-even? (dec n)))))
|
||||
|
||||
(defn is-even-bigint? [n]
|
||||
(loop [n n
|
||||
acc true]
|
||||
(if (= n 0)
|
||||
__
|
||||
acc
|
||||
(recur (dec n) (not acc)))))
|
||||
|
||||
(defn recursive-reverse [coll]
|
||||
__)
|
||||
(if (empty? coll)
|
||||
coll
|
||||
(concat (recursive-reverse (rest coll)) (list (first coll)))))
|
||||
|
||||
(defn factorial [n]
|
||||
__)
|
||||
(loop [n n
|
||||
acc 1]
|
||||
(if (= n 0)
|
||||
acc
|
||||
(recur (dec n) (* n acc)))
|
||||
))
|
||||
|
||||
(meditations
|
||||
"Recursion ends with a base case"
|
||||
|
||||
@ -8,37 +8,39 @@
|
||||
|
||||
(meditations
|
||||
"Destructuring is an arbiter: it breaks up arguments"
|
||||
(= __ ((fn [[a b]] (str b a))
|
||||
(= ":bar:foo" ((fn [[a b]] (str b a))
|
||||
[:foo :bar]))
|
||||
|
||||
"Whether in function definitions"
|
||||
(= (str "An Oxford comma list of apples, "
|
||||
"oranges, "
|
||||
"and pears.")
|
||||
((fn [[a b c]] __)
|
||||
((fn [[a b c]] (str "An Oxford comma list of " a ", " b ", and " c "."))
|
||||
["apples" "oranges" "pears"]))
|
||||
|
||||
"Or in let expressions"
|
||||
(= "Rich Hickey aka The Clojurer aka Go Time aka Lambda Guru"
|
||||
(let [[first-name last-name & aliases]
|
||||
(list "Rich" "Hickey" "The Clojurer" "Go Time" "Lambda Guru")]
|
||||
__))
|
||||
(clojure.string/join " aka " (conj aliases (str first-name " " last-name))))
|
||||
)
|
||||
|
||||
"You can regain the full argument if you like arguing"
|
||||
(= {:original-parts ["Stephen" "Hawking"] :named-parts {:first "Stephen" :last "Hawking"}}
|
||||
(let [[first-name last-name :as full-name] ["Stephen" "Hawking"]]
|
||||
__))
|
||||
{:original-parts full-name :named-parts {:first first-name :last last-name}}))
|
||||
|
||||
"Break up maps by key"
|
||||
(= "123 Test Lane, Testerville, TX"
|
||||
(let [{street-address :street-address, city :city, state :state} test-address]
|
||||
__))
|
||||
(str street-address ", " city ", " state)))
|
||||
|
||||
"Or more succinctly"
|
||||
(= "123 Test Lane, Testerville, TX"
|
||||
(let [{:keys [street-address __ __]} test-address]
|
||||
__))
|
||||
(let [{:keys [street-address city state]} test-address]
|
||||
(str street-address ", " city ", " state)))
|
||||
|
||||
"All together now!"
|
||||
(= "Test Testerson, 123 Test Lane, Testerville, TX"
|
||||
(___ ["Test" "Testerson"] test-address)))
|
||||
((fn [[first-name last-name] {:keys [street-address city state]}]
|
||||
(str first-name " " last-name ", " street-address ", " city ", " state)) ["Test" "Testerson"] test-address)))
|
||||
|
||||
@ -6,31 +6,31 @@
|
||||
|
||||
(meditations
|
||||
"In the beginning, there was a word"
|
||||
(= __ (deref the-world))
|
||||
(= "hello" (deref the-world))
|
||||
|
||||
"You can get the word more succinctly, but it's the same"
|
||||
(= __ @the-world)
|
||||
(= "hello" @the-world)
|
||||
|
||||
"You can be the change you wish to see in the world."
|
||||
(= __ (do
|
||||
(dosync (ref-set the-world "better"))
|
||||
@the-world))
|
||||
(= "better" (do
|
||||
(dosync (ref-set the-world "better"))
|
||||
@the-world))
|
||||
|
||||
"Alter where you need not replace"
|
||||
(= __ (let [exclamator (fn [x] (str x "!"))]
|
||||
(dosync
|
||||
(alter the-world exclamator)
|
||||
(alter the-world exclamator)
|
||||
(alter the-world exclamator))
|
||||
@the-world))
|
||||
(= "better!!!" (let [exclamator (fn [x] (str x "!"))]
|
||||
(dosync
|
||||
(alter the-world exclamator)
|
||||
(alter the-world exclamator)
|
||||
(alter the-world exclamator))
|
||||
@the-world))
|
||||
|
||||
"Don't forget to do your work in a transaction!"
|
||||
(= 0 (do __
|
||||
(= 0 (do (dosync (ref-set the-world 0))
|
||||
@the-world))
|
||||
|
||||
"Functions passed to alter may depend on the data in the ref"
|
||||
(= 20 (do
|
||||
(dosync (alter the-world ___))))
|
||||
(= 20 (do ()
|
||||
(dosync (alter the-world + 20))))
|
||||
|
||||
"Two worlds are better than one"
|
||||
(= ["Real Jerry" "Bizarro Jerry"]
|
||||
@ -39,4 +39,4 @@
|
||||
(ref-set the-world {})
|
||||
(alter the-world assoc :jerry "Real Jerry")
|
||||
(alter bizarro-world assoc :jerry "Bizarro Jerry")
|
||||
__))))
|
||||
[(:jerry @the-world) (:jerry @bizarro-world)]))))
|
||||
|
||||
@ -5,29 +5,29 @@
|
||||
|
||||
(meditations
|
||||
"Atoms are like refs"
|
||||
(= __ @atomic-clock)
|
||||
(= 0 @atomic-clock)
|
||||
|
||||
"You can change at the swap meet"
|
||||
(= __ (do
|
||||
(= 1 (do
|
||||
(swap! atomic-clock inc)
|
||||
@atomic-clock))
|
||||
|
||||
"Keep taxes out of this: swapping requires no transaction"
|
||||
(= 5 (do
|
||||
__
|
||||
(swap! atomic-clock + 4)
|
||||
@atomic-clock))
|
||||
|
||||
"Any number of arguments might happen during a swap"
|
||||
(= __ (do
|
||||
(= 20 (do
|
||||
(swap! atomic-clock + 1 2 3 4 5)
|
||||
@atomic-clock))
|
||||
|
||||
"Atomic atoms are atomic"
|
||||
(= __ (do
|
||||
(= 20 (do
|
||||
(compare-and-set! atomic-clock 100 :fin)
|
||||
@atomic-clock))
|
||||
|
||||
"When your expectations are aligned with reality, things proceed that way"
|
||||
(= :fin (do
|
||||
(compare-and-set! __ __ __)
|
||||
(compare-and-set! atomic-clock 20 :fin)
|
||||
@atomic-clock)))
|
||||
|
||||
@ -4,22 +4,22 @@
|
||||
|
||||
(meditations
|
||||
"Wrap a quote around a list to suppress evaluation"
|
||||
(= (quote (1 2 3 4 5)) __)
|
||||
(= (quote (1 2 3 4 5)) [ 1 2 3 4 5 ])
|
||||
|
||||
"There is a shortcut too!"
|
||||
(= (quote __) '(1 2 3 4 5))
|
||||
(= (quote (1 2 3 4 5)) '(1 2 3 4 5))
|
||||
|
||||
"You can quote symbols as well as lists... without evaluation!"
|
||||
(= __ (let [age 9] (quote age)))
|
||||
(= 'age (let [age 9] (quote age)))
|
||||
|
||||
"You can use a literal list as a data collection without having Clojure try to call a function"
|
||||
(= (cons 1 (__ (2 3))) (list 1 2 3) (cons 1 [2 3]))
|
||||
(= (cons 1 (quote (2 3))) (list 1 2 3) (cons 1 [2 3]))
|
||||
|
||||
"The quote affects all of its arguments, not just the top level"
|
||||
(= (list 1 __) '(1 (+ 2 3)))
|
||||
(= (list 1 (quote (+ 2 3))) '(1 (+ 2 3)))
|
||||
|
||||
"Syntax-quote (`) acts similarly to the normal quote"
|
||||
(= (list __ __ __) `(1 2 3) '(1 2 3))
|
||||
(= (list 1 2 3) `(1 2 3) '(1 2 3))
|
||||
|
||||
"Unquote (~) within a syntax-quoted expression lets you mark specific expressions as requiring evaluation"
|
||||
(= (list __ __) `(1 ~(+ 2 3)) '(1 5)))
|
||||
(= (list 1 5) `(1 ~(+ 2 3)) '(1 5)))
|
||||
|
||||
@ -18,30 +18,39 @@
|
||||
(deftype Razzie [category]
|
||||
Award
|
||||
(present [this recipient]
|
||||
__))
|
||||
(print
|
||||
(str "You're really the "
|
||||
(.category this) ", "
|
||||
recipient
|
||||
"... sorry.")
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
(meditations
|
||||
"Holding records is meaningful only when the record is worthy of you"
|
||||
(= __ (.prize (Nobel. "peace")))
|
||||
(= "peace" (.prize (Nobel. "peace")))
|
||||
|
||||
"Types are quite similar"
|
||||
(= __ (.prize (Pulitzer. "literature")))
|
||||
(= "literature" (.prize (Pulitzer. "literature")))
|
||||
|
||||
"Records may be treated like maps"
|
||||
(= __ (:prize (Nobel. "physics")))
|
||||
(= "physics" (:prize (Nobel. "physics")))
|
||||
|
||||
"While types may not"
|
||||
(= __ (:prize (Pulitzer. "poetry")))
|
||||
(= nil (:prize (Pulitzer. "poetry")))
|
||||
|
||||
"Further study reveals why"
|
||||
(= __
|
||||
(= '(true false)
|
||||
(map map? [(Nobel. "chemistry")
|
||||
(Pulitzer. "music")]))
|
||||
|
||||
"Either sort of datatype can define methods in a protocol"
|
||||
(= __
|
||||
(= "Congratulations on your Best Picture Oscar, Evil Alien Conquerors!"
|
||||
(with-out-str (present (Oscar. "Best Picture") "Evil Alien Conquerors")))
|
||||
|
||||
"Surely we can implement our own by now"
|
||||
(= "You're really the Worst Picture, Final Destination 5... sorry."
|
||||
(with-out-str (present (Razzie. "Worst Picture") "Final Destination 5"))))
|
||||
(with-out-str (present (Razzie. "Worst Picture") "Final Destination 5"))
|
||||
)
|
||||
)
|
||||
|
||||
@ -3,17 +3,17 @@
|
||||
|
||||
(meditations
|
||||
"You may have done more with Java than you know"
|
||||
(= __ (class "warfare")) ; hint: try typing (javadoc "warfare") in the REPL
|
||||
(= String (class "warfare")) ; hint: try typing (javadoc "warfare") in the REPL
|
||||
|
||||
"The dot signifies easy and direct Java interoperation"
|
||||
(= __ (.toUpperCase "select * from"))
|
||||
(= "SELECT * FROM" (.toUpperCase "select * from"))
|
||||
|
||||
"But instance method calls are very different from normal functions"
|
||||
(= ["SELECT" "FROM" "WHERE"] (map ___ ["select" "from" "where"]))
|
||||
(= ["SELECT" "FROM" "WHERE"] (map #(.toUpperCase %) ["select" "from" "where"]))
|
||||
|
||||
"Constructing might be harder than breaking"
|
||||
(= 10 (let [latch (java.util.concurrent.CountDownLatch. __)]
|
||||
(= 10 (let [latch (java.util.concurrent.CountDownLatch. 10)]
|
||||
(.getCount latch)))
|
||||
|
||||
"Static methods are slashing prices!"
|
||||
(== __ (Math/pow 2 10)))
|
||||
(== 1024 (Math/pow 2 10)))
|
||||
|
||||
@ -3,19 +3,19 @@
|
||||
|
||||
(meditations
|
||||
"To split a collection you can use the partition function"
|
||||
(= '((0 1) (2 3)) (__ 2 (range 4)))
|
||||
(= '((0 1) (2 3)) (partition 2 (range 4)))
|
||||
|
||||
"But watch out if there are not enough elements to form n sequences"
|
||||
(= '(__) (partition 3 [:a :b :c :d :e]))
|
||||
(= '((:a :b :c)) (partition 3 [:a :b :c :d :e]))
|
||||
|
||||
"You can use partition-all to include any leftovers too"
|
||||
(= __ (partition-all 3 (range 5)))
|
||||
(= '((0 1 2) (3 4)) (partition-all 3 (range 5)))
|
||||
|
||||
"If you need to, you can start each sequence with an offset"
|
||||
(= '((0 1 2) (5 6 7) (10 11 12)) (partition 3 __ (range 13)))
|
||||
(= '((0 1 2) (5 6 7) (10 11 12)) (partition 3 5 (range 13)))
|
||||
|
||||
"Consider padding the last sequence with some default values..."
|
||||
(= '((0 1 2) (3 4 5) (6 :hello)) (partition 3 3 [__] (range 7)))
|
||||
(= '((0 1 2) (3 4 5) (6 :hello)) (partition 3 3 [:hello] (range 7)))
|
||||
|
||||
"... but notice that they will only pad up to the given sequence length"
|
||||
(= '((0 1 2) (3 4 5) __) (partition 3 3 [:these :are "my" "words"] (range 7))))
|
||||
(= '((0 1 2) (3 4 5) (6 :these :are)) (partition 3 3 [:these :are "my" "words"] (range 7))))
|
||||
|
||||
@ -2,12 +2,12 @@
|
||||
(:require [koan-engine.core :refer :all]))
|
||||
|
||||
(defn get-odds-and-evens [coll]
|
||||
(let [{odds true evens false} (group-by __ coll)]
|
||||
(let [{odds true evens false} (group-by odd? coll)]
|
||||
[odds evens]))
|
||||
|
||||
(meditations
|
||||
"To categorize a collection by some function, use group-by."
|
||||
(= __ (group-by count ["hello" "world" "foo" "bar"]))
|
||||
(= {3 '("foo" "bar") 5 '("hello" "world")} (group-by count ["hello" "world" "foo" "bar"]))
|
||||
|
||||
"You can simulate filter + remove in one pass"
|
||||
(= (get-odds-and-evens [1 2 3 4 5])
|
||||
@ -15,7 +15,9 @@
|
||||
[[1 3 5] [2 4]])
|
||||
|
||||
"You can also group by a primary key"
|
||||
(= __
|
||||
(= {1 '({:id 1 :name "Bob"}
|
||||
{:id 1 :last-name "Smith"})
|
||||
2 '({:id 2 :name "Jennifer"})}
|
||||
(group-by :id [{:id 1 :name "Bob"}
|
||||
{:id 2 :name "Jennifer"}
|
||||
{:id 1 :last-name "Smith"} ]))
|
||||
@ -23,13 +25,13 @@
|
||||
"But be careful when you group by a non-required key"
|
||||
(= {"Bob" [{:name "Bob" :id 1}]
|
||||
"Jennifer" [{:name "Jennifer" :id 2}]
|
||||
__ [{:last-name "Smith" :id 1}]}
|
||||
nil [{:last-name "Smith" :id 1}]}
|
||||
(group-by :name [{:id 1 :name "Bob"}
|
||||
{:id 2 :name "Jennifer"}
|
||||
{:id 1 :last-name "Smith"}]))
|
||||
|
||||
"The true power of group-by comes with custom functions"
|
||||
(= __
|
||||
(= {:naughty-list '({:name "Jimmy" :bad true} {:name "Joe" :bad true}) :nice-list '({:name "Jane" :bad false})}
|
||||
(group-by #(if (:bad %) :naughty-list :nice-list)
|
||||
[{:name "Jimmy" :bad true}
|
||||
{:name "Jane" :bad false}
|
||||
|
||||
@ -7,13 +7,13 @@
|
||||
|
||||
(meditations
|
||||
"Some objects can be tagged using the with-meta function"
|
||||
(= __ (meta giants))
|
||||
(= {:league "National League"} (meta giants))
|
||||
|
||||
"Or more succinctly with a reader macro"
|
||||
(= __ (meta '^{:division "West"} Giants))
|
||||
(= {:division "West"} (meta '^{:division "West"} Giants))
|
||||
|
||||
"While others can't"
|
||||
(= __ (try
|
||||
(= "This doesn't implement the IObj interface" (try
|
||||
(with-meta
|
||||
2
|
||||
{:prime true})
|
||||
@ -21,31 +21,31 @@
|
||||
"This doesn't implement the IObj interface")))
|
||||
|
||||
"Notice when metadata carries over"
|
||||
(= __ (meta (merge '^{:foo :bar} {:a 1 :b 2}
|
||||
(= {:foo :bar } (meta (merge '^{:foo :bar} {:a 1 :b 2}
|
||||
{:b 3 :c 4})))
|
||||
|
||||
"And when it doesn't"
|
||||
(= __ (meta (merge {:a 1 :b 2}
|
||||
(= nil (meta (merge {:a 1 :b 2}
|
||||
'^{:foo :bar} {:b 3 :c 4})))
|
||||
|
||||
"Metadata can be used as a type hint to avoid reflection during runtime"
|
||||
(= __ (#(.charAt ^String % 0) "Cast me"))
|
||||
(= \C (#(.charAt ^String % 0) "Cast me"))
|
||||
|
||||
"You can directly update an object's metadata"
|
||||
(= 8 (let [giants
|
||||
(with-meta
|
||||
'Giants
|
||||
{:world-series-titles (atom 7)})]
|
||||
(swap! (:world-series-titles (meta giants)) __)
|
||||
(swap! (:world-series-titles (meta giants)) inc)
|
||||
@(:world-series-titles (meta giants))))
|
||||
|
||||
"You can also create a new object from another object with metadata"
|
||||
(= {:league "National League" :park "AT&T Park"}
|
||||
(meta (vary-meta giants
|
||||
assoc __ __)))
|
||||
assoc :park "AT&T Park")))
|
||||
|
||||
"But it won't affect behavior like equality"
|
||||
(= __ (vary-meta giants dissoc :league))
|
||||
(= giants (vary-meta giants dissoc :league))
|
||||
|
||||
"Or the object's printed representation"
|
||||
(= __ (pr-str (vary-meta giants dissoc :league))))
|
||||
(= "Giants" (pr-str (vary-meta giants dissoc :league))))
|
||||
|
||||
@ -9,31 +9,31 @@
|
||||
|
||||
(defmacro infix-concise [form]
|
||||
`(~(second form) ; Note the syntax-quote (`) and unquote (~) characters!
|
||||
__
|
||||
__))
|
||||
~(first form)
|
||||
~(nth form 2)))
|
||||
|
||||
(defmacro recursive-infix [form]
|
||||
(cond (not (seq? form))
|
||||
__
|
||||
form
|
||||
(= 1 (count form))
|
||||
`(recursive-infix ~(first form))
|
||||
:else
|
||||
(let [operator (second form)
|
||||
first-arg (first form)
|
||||
others __]
|
||||
others (drop 2 form)]
|
||||
`(~operator
|
||||
(recursive-infix ~first-arg)
|
||||
(recursive-infix ~others)))))
|
||||
|
||||
(meditations
|
||||
"Macros are like functions created at compile time"
|
||||
(= __ (hello "Macros!"))
|
||||
(= "Hello, Macros!" (hello "Macros!"))
|
||||
|
||||
"I can haz infix?"
|
||||
(= __ (infix (9 + 1)))
|
||||
(= (+ 9 1) (infix (9 + 1)))
|
||||
|
||||
"Remember, these are nothing but code transformations"
|
||||
(= __ (macroexpand '(infix (9 + 1))))
|
||||
(= '(+ 9 1) (macroexpand '(infix (9 + 1))))
|
||||
|
||||
"You can do better than that - hand crafting FTW!"
|
||||
(= '(* 10 2) (macroexpand '(infix-concise (10 * 2))))
|
||||
|
||||
Loading…
Reference in New Issue
Block a user