luciano/clojure-koans
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Reformat all koan files for REPL compatibility.

Browse source
This commit is contained in:
frizzbolt 2016-02-26 20:33:05 -06:00
parent e1cc8a72b4
commit dc460acdda
22 changed files with 224 additions and 357 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

50
02_strings.clj
View file

@ -1,70 +1,66 @@
(ns koans.02-strings
(:require [koan-engine.core :refer :all]
[clojure.string :as string]))
(meditations
"A string is nothing more than text surrounded by double quotes"
; "A string is nothing more than text surrounded by double quotes"
(= __ "hello")
"But double quotes are just magic on top of something deeper"
; "But double quotes are just magic on top of something deeper"
(= __ (str 'world))
"You can do more than create strings, you can put them together"
; "You can do more than create strings, you can put them together"
(= "Cool right?" (str __ __))
"You can even get certain characters"
; "You can even get certain characters"
(= \C (get "Characters" __))
"Or even count the characters"
; "Or even count the characters"
(= __ (count "Hello World"))
"But strings and characters are not the same"
; "But strings and characters are not the same"
(= __ (= \c "c"))
"What if you only wanted to get part of a string?"
; "What if you only wanted to get part of a string?"
(= "World" (subs "Hello World" __ __))
"How about joining together elements in a list?"
; "How about joining together elements in a list?"
(= __ (string/join '(1 2 3)))
"What if you wanted to separate them out?"
; "What if you wanted to separate them out?"
(= "1, 2, 3" (string/join __ '(1 2 3)))
"Maybe you want to separate out all your lines"
; "Maybe you want to separate out all your lines"
(= [__ __ __] (string/split-lines "1\n2\n3"))
"You may want to make sure your words are backwards"
; "You may want to make sure your words are backwards"
(= __ (string/reverse "hello"))
"Maybe you want to find the index of the first occurence of a substring"
; "Maybe you want to find the index of the first occurence of a substring"
(= 0 (string/index-of "hello world" __))
"Or maybe the last index of the same"
; "Or maybe the last index of the same"
(= __ (string/last-index-of "hello world, hello" "hello"))
"But when something doesn't exist, nothing is found"
; "But when something doesn't exist, nothing is found"
(= __ (string/index-of "hello world" "bob"))
"Sometimes you don't want whitespace cluttering the front and back"
; "Sometimes you don't want whitespace cluttering the front and back"
(= __ (string/trim " \nhello world \t \n"))
"You can check if something is a char"
; "You can check if something is a char"
(= __ (char? \c))
"But it may not be"
; "But it may not be"
(= __ (char? "a"))
"But chars aren't strings"
; "But chars aren't strings"
(= __ (string? \b))
"Strings are strings"
; "Strings are strings"
(= true (string? __))
"Some strings may be blank"
; "Some strings may be blank"
(= __ (string/blank? ""))
"Even if at first glance they aren't"
; "Even if at first glance they aren't"
(= __ (string/blank? " \n \t "))
"However, most strings aren't blank"
(= __ (string/blank? "hello?\nare you out there?")))
; "However, most strings aren't blank"
(= __ (string/blank? "hello?\nare you out there?"))

29
03_lists.clj
View file

@ -1,45 +1,42 @@
(ns koans.03-lists
(:require [koan-engine.core :refer :all]))
(meditations
"Lists can be expressed by function or a quoted form"
; "Lists can be expressed by function or a quoted form"
(= '(__ __ __ __ __) (list 1 2 3 4 5))
"They are Clojure seqs (sequences), so they allow access to the first"
; "They are Clojure seqs (sequences), so they allow access to the first"
(= __ (first '(1 2 3 4 5)))
"As well as the rest"
; "As well as the rest"
(= __ (rest '(1 2 3 4 5)))
"Count your blessings"
; "Count your blessings"
(= __ (count '(dracula dooku chocula)))
"Before they are gone"
; "Before they are gone"
(= __ (count '()))
"The rest, when nothing is left, is empty"
; "The rest, when nothing is left, is empty"
(= __ (rest '(100)))
"Construction by adding an element to the front is easy"
; "Construction by adding an element to the front is easy"
(= __ (cons :a '(:b :c :d :e)))
"Conjoining an element to a list isn't hard either"
; "Conjoining an element to a list isn't hard either"
(= __ (conj '(:a :b :c :d) :e))
"You can use a list like a stack to get the first element"
; "You can use a list like a stack to get the first element"
(= __ (peek '(:a :b :c :d :e)))
"Or the others"
; "Or the others"
(= __ (pop '(:a :b :c :d :e)))
"But watch out if you try to pop nothing"
; "But watch out if you try to pop nothing"
(= __ (try
(pop '())
(catch IllegalStateException e
"No dice!")))
"The rest of nothing isn't so strict"
; "The rest of nothing isn't so strict"
(= __ (try
(rest '())
(catch IllegalStateException e
"No dice!"))))
"No dice!")))

25
04_vectors.clj
View file

@ -1,33 +1,30 @@
(ns koans.04-vectors
(:require [koan-engine.core :refer :all]))
(meditations
"You can use vectors in clojure as array-like structures"
; "You can use vectors in clojure as array-like structures"
(= __ (count [42]))
"You can create a vector from a list"
; "You can create a vector from a list"
(= __ (vec '(1)))
"Or from some elements"
; "Or from some elements"
(= __ (vector nil nil))
"But you can populate it with any number of elements at once"
; "But you can populate it with any number of elements at once"
(= [1 __] (vec '(1 2)))
"Conjoining to a vector is different than to a list"
; "Conjoining to a vector is different than to a list"
(= __ (conj [111 222] 333))
"You can get the first element of a vector like so"
; "You can get the first element of a vector like so"
(= __ (first [:peanut :butter :and :jelly]))
"And the last in a similar fashion"
; "And the last in a similar fashion"
(= __ (last [:peanut :butter :and :jelly]))
"Or any index if you wish"
; "Or any index if you wish"
(= __ (nth [:peanut :butter :and :jelly] 3))
"You can also slice a vector"
; "You can also slice a vector"
(= __ (subvec [:peanut :butter :and :jelly] 1 3))
"Equality with collections is in terms of values"
(= (list 1 2 3) (vector 1 2 __)))
; "Equality with collections is in terms of values"
(= (list 1 2 3) (vector 1 2 __))

18
05_sets.clj
View file

@ -1,22 +1,18 @@
(ns koans.05-sets
(:require [koan-engine.core :refer :all]
[clojure.set :as set]))
(meditations
"You can create a set by converting another collection"
; "You can create a set by converting another collection"
(= #{3} (set __))
"Counting them is like counting other collections"
; "Counting them is like counting other collections"
(= __ (count #{1 2 3}))
"Remember that a set is a *mathematical* set"
; "Remember that a set is a *mathematical* set"
(= __ (set '(1 1 2 2 3 3 4 4 5 5)))
"You can ask clojure for the union of two sets"
; "You can ask clojure for the union of two sets"
(= __ (set/union #{1 2 3 4} #{2 3 5}))
"And also the intersection"
; "And also the intersection"
(= __ (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})))
; "But don't forget about the difference"
(= __ (set/difference #{1 2 3 4 5} #{2 3 5}))

35
06_maps.clj
View file

@ -1,50 +1,47 @@
(ns koans.06-maps
(:require [koan-engine.core :refer :all]))
(meditations
"Don't get lost when creating a map"
; "Don't get lost when creating a map"
(= {:a 1 :b 2} (hash-map :a 1 __ __))
"A value must be supplied for each key"
; "A value must be supplied for each key"
(= {:a 1} (hash-map :a __))
"The size is the number of entries"
; "The size is the number of entries"
(= __ (count {:a 1 :b 2}))
"You can look up the value for a given key"
; "You can look up the value for a given key"
(= __ (get {:a 1 :b 2} :b))
"Maps can be used as functions to do lookups"
; "Maps can be used as functions to do lookups"
(= __ ({:a 1 :b 2} :a))
"And so can keywords"
; "And so can keywords"
(= __ (:a {:a 1 :b 2}))
"But map keys need not be keywords"
; "But map keys need not be keywords"
(= __ ({2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"} 2014))
"You may not be able to find an entry for a key"
; "You may not be able to find an entry for a key"
(= __ (get {:a 1 :b 2} :c))
"But you can provide your own default"
; "But you can provide your own default"
(= __ (get {:a 1 :b 2} :c :key-not-found))
"You can find out if a key is present"
; "You can find out if a key is present"
(= __ (contains? {:a nil :b nil} :b))
"Or if it is missing"
; "Or if it is missing"
(= __ (contains? {:a nil :b nil} :c))
"Maps are immutable, but you can create a new and improved version"
; "Maps are immutable, but you can create a new and improved version"
(= {1 "January" 2 __} (assoc {1 "January"} 2 "February"))
"You can also create a new version with an entry removed"
; "You can also create a new version with an entry removed"
(= {__ __} (dissoc {1 "January" 2 "February"} 2))
"Often you will need to get the keys, but the order is undependable"
; "Often you will need to get the keys, but the order is undependable"
(= (list __ __ __)
(sort (keys { 2014 "Sochi" 2018 "PyeongChang" 2010 "Vancouver"})))
"You can get the values in a similar way"
; "You can get the values in a similar way"
(= (list __ __ __)
(sort (vals {2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"}))))
(sort (vals {2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"})))

30
07_functions.clj
View file

@ -1,40 +1,32 @@
(ns koans.07-functions
(:require [koan-engine.core :refer :all]))
(defn multiply-by-ten [n]
(* 10 n))
(defn square [n] (* n n))
(meditations
"Calling a function is like giving it a hug with parentheses"
; "Calling a function is like giving it a hug with parentheses"
(= __ (square 9))
"Functions are usually defined before they are used"
; "Functions are usually defined before they are used"
(= __ (multiply-by-ten 2))
"But they can also be defined inline"
; "But they can also be defined inline"
(= __ ((fn [n] (* 5 n)) 2))
"Or using an even shorter syntax"
; "Or using an even shorter syntax"
(= __ (#(* 15 %) 4))
"Even anonymous functions may take multiple arguments"
; "Even anonymous functions may take multiple arguments"
(= __ (#(+ %1 %2 %3) 4 5 6))
"Arguments can also be skipped"
; "Arguments can also be skipped"
(= __ (#(* 15 %2) 1 2))
"One function can beget another"
; "One function can beget another"
(= 9 (((fn [] ___)) 4 5))
"Functions can also take other functions as input"
; "Functions can also take other functions as input"
(= 20 ((fn [f] (f 4 5))
___))
"Higher-order functions take function arguments"
; "Higher-order functions take function arguments"
(= 25 (___
(fn [n] (* n n))))
"But they are often better written using the names of functions"
(= 25 (___ square)))
; "But they are often better written using the names of functions"
(= 25 (___ square))

28
08_conditionals.clj
View file

@ -1,47 +1,37 @@
(ns koans.08-conditionals
(:require [koan-engine.core :refer :all]))
(defn explain-exercise-velocity [exercise-term]
(case exercise-term
:bicycling "pretty fast"
:jogging "not super fast"
:walking "not fast at all"
"is that even exercise?"))
(meditations
"You will face many decisions"
; "You will face many decisions"
(= __ (if (false? (= 4 5))
:a
:b))
"Some of them leave you no alternative"
; "Some of them leave you no alternative"
(= __ (if (> 4 3)
[]))
"And in such a situation you may have nothing"
; "And in such a situation you may have nothing"
(= __ (if (nil? 0)
[:a :b :c]))
"In others your alternative may be interesting"
; "In others your alternative may be interesting"
(= :glory (if (not (empty? ()))
:doom
__))
"You may have a multitude of possible paths"
; "You may have a multitude of possible paths"
(let [x 5]
(= :your-road (cond (= x __) :road-not-taken
(= x __) :another-road-not-taken
:else __)))
"Or your fate may be sealed"
; "Or your fate may be sealed"
(= 'doom (if-not (zero? __)
'doom
'more-doom))
"In case of emergency, go fast"
; "In case of emergency, go fast"
(= "pretty fast"
(explain-exercise-velocity __))
"But admit it when you don't know what to do"
; "But admit it when you don't know what to do"
(= __
(explain-exercise-velocity :watching-tv)))
(explain-exercise-velocity :watching-tv))

25
09_higher_order_functions.clj
View file

@ -1,35 +1,32 @@
(ns koans.09-higher-order-functions
(:require [koan-engine.core :refer :all]))
(meditations
"The map function relates a sequence to another"
; "The map function relates a sequence to another"
(= [__ __ __] (map (fn [x] (* 4 x)) [1 2 3]))
"You may create that mapping"
; "You may create that mapping"
(= [1 4 9 16 25] (map (fn [x] __) [1 2 3 4 5]))
"Or use the names of existing functions"
; "Or use the names of existing functions"
(= __ (map nil? [:a :b nil :c :d]))
"A filter can be strong"
; "A filter can be strong"
(= __ (filter (fn [x] false) '(:anything :goes :here)))
"Or very weak"
; "Or very weak"
(= __ (filter (fn [x] true) '(:anything :goes :here)))
"Or somewhere in between"
; "Or somewhere in between"
(= [10 20 30] (filter (fn [x] __) [10 20 30 40 50 60 70 80]))
"Maps and filters may be combined"
; "Maps and filters may be combined"
(= [10 20 30] (map (fn [x] __) (filter (fn [x] __) [1 2 3 4 5 6 7 8])))
"Reducing can increase the result"
; "Reducing can increase the result"
(= __ (reduce (fn [a b] (* a b)) [1 2 3 4]))
"You can start somewhere else"
; "You can start somewhere else"
(= 2400 (reduce (fn [a b] (* a b)) __ [1 2 3 4]))
"Numbers are not the only things one can reduce"
; "Numbers are not the only things one can reduce"
(= "longest" (reduce (fn [a b]
(if (< __ __) b a))
["which" "word" "is" "longest"])))
["which" "word" "is" "longest"]))

32
10_runtime_polymorphism.clj
View file

@ -1,42 +1,26 @@
(ns koans.10-runtime-polymorphism
(:require [koan-engine.core :refer :all]))
(defn hello
([] "Hello World!")
([a] (str "Hello, you silly " a "."))
([a & more] (str "Hello to this group: "
(apply str
(interpose ", " (cons a more)))
"!")))
(defmulti diet (fn [x] (:eater x)))
(defmethod diet :herbivore [a] __)
(defmethod diet :carnivore [a] __)
(defmethod diet :default [a] __)
(meditations
"Some functions can be used in different ways - with no arguments"
; "Some functions can be used in different ways - with no arguments"
(= __ (hello))
"With one argument"
; "With one argument"
(= __ (hello "world"))
"Or with many arguments"
; "Or with many arguments"
(= __
(hello "Peter" "Paul" "Mary"))
"Multimethods allow more complex dispatching"
; "Multimethods allow more complex dispatching"
(= "Bambi eats veggies."
(diet {:species "deer" :name "Bambi" :age 1 :eater :herbivore}))
"Animals have different names"
; "Animals have different names"
(= "Thumper eats veggies."
(diet {:species "rabbit" :name "Thumper" :age 1 :eater :herbivore}))
"Different methods are used depending on the dispatch function result"
; "Different methods are used depending on the dispatch function result"
(= "Simba eats animals."
(diet {:species "lion" :name "Simba" :age 1 :eater :carnivore}))
"You may use a default method when no others match"
; "You may use a default method when no others match"
(= "I don't know what Rich Hickey eats."
(diet {:name "Rich Hickey"})))
(diet {:name "Rich Hickey"}))

19
11_lazy_sequences.clj
View file

@ -1,28 +1,25 @@
(ns koans.11-lazy-sequences
(:require [koan-engine.core :refer :all]))
(meditations
"There are many ways to generate a sequence"
; "There are many ways to generate a sequence"
(= __ (range 1 5))
"The range starts at the beginning by default"
; "The range starts at the beginning by default"
(= __ (range 5))
"Only take what you need when the sequence is large"
; "Only take what you need when the sequence is large"
(= [0 1 2 3 4 5 6 7 8 9]
(take __ (range 100)))
"Or limit results by dropping what you don't need"
; "Or limit results by dropping what you don't need"
(= [95 96 97 98 99]
(drop __ (range 100)))
"Iteration provides an infinite lazy sequence"
; "Iteration provides an infinite lazy sequence"
(= __ (take 20 (iterate inc 0)))
"Repetition is key"
; "Repetition is key"
(= [:a :a :a :a :a :a :a :a :a :a]
(repeat 10 __))
"Iteration can be used for repetition"
; "Iteration can be used for repetition"
(= (repeat 100 :hello)
(take 100 (iterate ___ :hello))))
(take 100 (iterate ___ :hello)))

15
12_sequence_comprehensions.clj
View file

@ -1,36 +1,33 @@
(ns koans.12-sequence-comprehensions
(:require [koan-engine.core :refer :all]))
(meditations
"Sequence comprehensions can bind each element in turn to a symbol"
; "Sequence comprehensions can bind each element in turn to a symbol"
(= __
(for [x (range 6)]
x))
"They can easily emulate mapping"
; "They can easily emulate mapping"
(= '(0 1 4 9 16 25)
(map (fn [x] (* x x))
(range 6))
(for [x (range 6)]
__))
"And also filtering"
; "And also filtering"
(= '(1 3 5 7 9)
(filter odd? (range 10))
(for [x __ :when (odd? x)]
x))
"Combinations of these transformations is trivial"
; "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 __]
__))
"More complex transformations simply take multiple binding forms"
; "More complex transformations simply take multiple binding forms"
(= [[:top :left] [:top :middle] [:top :right]
[:middle :left] [:middle :middle] [:middle :right]
[:bottom :left] [:bottom :middle] [:bottom :right]]
(for [row [:top :middle :bottom]
column [:left :middle :right]]
__)))
__))

21
13_creating_functions.clj
View file

@ -1,35 +1,30 @@
(ns koans.13-creating-functions
(:require [koan-engine.core :refer :all]))
(defn square [x] (* x x))
(meditations
"One may know what they seek by knowing what they do not seek"
; "One may know what they seek by knowing what they do not seek"
(= [__ __ __] (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"
; "Praise and 'complement' may help you separate the wheat from the chaff"
(= [:wheat "wheat" 'wheat]
(let [not-nil? ___]
(filter not-nil? [nil :wheat nil "wheat" nil 'wheat nil])))
"Partial functions allow procrastination"
; "Partial functions allow procrastination"
(= 20 (let [multiply-by-5 (partial * 5)]
(___ __)))
"Don't forget: first things first"
; "Don't forget: first things first"
(= [__ __ __ __]
(let [ab-adder (partial concat [:a :b])]
(ab-adder [__ __])))
"Functions can join forces as one 'composed' function"
; "Functions can join forces as one 'composed' function"
(= 25 (let [inc-and-square (comp square inc)]
(inc-and-square __)))
"Have a go on a double dec-er"
; "Have a go on a double dec-er"
(= __ (let [double-dec (comp dec dec)]
(double-dec 10)))
"Be careful about the order in which you mix your functions"
; "Be careful about the order in which you mix your functions"
(= 99 (let [square-and-dec ___]
(square-and-dec 10))))
(square-and-dec 10)))

36
14_recursion.clj
View file

@ -1,54 +1,50 @@
(ns koans.14-recursion
(:require [koan-engine.core :refer :all]))
(defn is-even? [n]
(defn is-even? [n]
(if (= n 0)
__
(___ (is-even? (dec n)))))
(defn is-even-bigint? [n]
(defn is-even-bigint? [n]
(loop [n n
acc true]
(if (= n 0)
__
(recur (dec n) (not acc)))))
(defn recursive-reverse [coll]
(defn recursive-reverse [coll]
__)
(defn factorial [n]
(defn factorial [n]
__)
(meditations
"Recursion ends with a base case"
; "Recursion ends with a base case"
(= true (is-even? 0))
"And starts by moving toward that base case"
; "And starts by moving toward that base case"
(= false (is-even? 1))
"Having too many stack frames requires explicit tail calls with recur"
; "Having too many stack frames requires explicit tail calls with recur"
(= false (is-even-bigint? 100003N))
"Reversing directions is easy when you have not gone far"
; "Reversing directions is easy when you have not gone far"
(= '(1) (recursive-reverse [1]))
"Yet it becomes more difficult the more steps you take"
; "Yet it becomes more difficult the more steps you take"
(= '(5 4 3 2 1) (recursive-reverse [1 2 3 4 5]))
"Simple things may appear simple."
; "Simple things may appear simple."
(= 1 (factorial 1))
"They may require other simple steps."
; "They may require other simple steps."
(= 2 (factorial 2))
"Sometimes a slightly bigger step is necessary"
; "Sometimes a slightly bigger step is necessary"
(= 6 (factorial 3))
"And eventually you must think harder"
; "And eventually you must think harder"
(= 24 (factorial 4))
"You can even deal with very large numbers"
; "You can even deal with very large numbers"
(< 1000000000000000000000000N (factorial 1000N))
"But what happens when the machine limits you?"
(< 1000000000000000000000000N (factorial 100003N)))
; "But what happens when the machine limits you?"
(< 1000000000000000000000000N (factorial 100003N))

24
15_destructuring.clj
View file

@ -1,44 +1,36 @@
(ns koans.15-destructuring
(:require [koan-engine.core :refer :all]))
(def test-address
{:street-address "123 Test Lane"
:city "Testerville"
:state "TX"})
(meditations
"Destructuring is an arbiter: it breaks up arguments"
; "Destructuring is an arbiter: it breaks up arguments"
(= __ ((fn [[a b]] (str b a))
[:foo :bar]))
"Whether in function definitions"
; "Whether in function definitions"
(= (str "An Oxford comma list of apples, "
"oranges, "
"and pears.")
((fn [[a b c]] __)
["apples" "oranges" "pears"]))
"Or in let expressions"
; "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")]
__))
"You can regain the full argument if you like arguing"
; "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"]]
__))
"Break up maps by key"
; "Break up maps by key"
(= "123 Test Lane, Testerville, TX"
(let [{street-address :street-address, city :city, state :state} test-address]
__))
"Or more succinctly"
; "Or more succinctly"
(= "123 Test Lane, Testerville, TX"
(let [{:keys [street-address __ __]} test-address]
__))
"All together now!"
; "All together now!"
(= "Test Testerson, 123 Test Lane, Testerville, TX"
(___ ["Test" "Testerson"] test-address)))
(___ ["Test" "Testerson"] test-address))

22
16_refs.clj
View file

@ -1,22 +1,16 @@
(ns koans.16-refs
(:require [koan-engine.core :refer :all]))
(def the-world (ref "hello"))
(def bizarro-world (ref {}))
(meditations
"In the beginning, there was a word"
; "In the beginning, there was a word"
(= __ (deref the-world))
"You can get the word more succinctly, but it's the same"
; "You can get the word more succinctly, but it's the same"
(= __ @the-world)
"You can be the change you wish to see in the world."
; "You can be the change you wish to see in the world."
(= __ (do
(dosync (ref-set the-world "better"))
@the-world))
"Alter where you need not replace"
; "Alter where you need not replace"
(= __ (let [exclamator (fn [x] (str x "!"))]
(dosync
(alter the-world exclamator)
@ -24,19 +18,19 @@
(alter the-world exclamator))
@the-world))
"Don't forget to do your work in a transaction!"
; "Don't forget to do your work in a transaction!"
(= 0 (do __
@the-world))
"Functions passed to alter may depend on the data in the ref"
; "Functions passed to alter may depend on the data in the ref"
(= 20 (do
(dosync (alter the-world ___))))
"Two worlds are better than one"
; "Two worlds are better than one"
(= ["Real Jerry" "Bizarro Jerry"]
(do
(dosync
(ref-set the-world {})
(alter the-world assoc :jerry "Real Jerry")
(alter bizarro-world assoc :jerry "Bizarro Jerry")
__))))
__)))

19
17_atoms.clj
View file

@ -1,33 +1,28 @@
(ns koans.17-atoms
(:require [koan-engine.core :refer :all]))
(def atomic-clock (atom 0))
(meditations
"Atoms are like refs"
; "Atoms are like refs"
(= __ @atomic-clock)
"You can change at the swap meet"
; "You can change at the swap meet"
(= __ (do
(swap! atomic-clock inc)
@atomic-clock))
"Keep taxes out of this: swapping requires no transaction"
; "Keep taxes out of this: swapping requires no transaction"
(= 5 (do
__
@atomic-clock))
"Any number of arguments might happen during a swap"
; "Any number of arguments might happen during a swap"
(= __ (do
(swap! atomic-clock + 1 2 3 4 5)
@atomic-clock))
"Atomic atoms are atomic"
; "Atomic atoms are atomic"
(= __ (do
(compare-and-set! atomic-clock 100 :fin)
@atomic-clock))
"When your expectations are aligned with reality, things proceed that way"
; "When your expectations are aligned with reality, things proceed that way"
(= :fin (do
(compare-and-set! __ __ __)
@atomic-clock)))
@atomic-clock))

17
18_macros.clj
View file

@ -1,5 +1,3 @@
(ns koans.18-macros
(:require [koan-engine.core :refer :all]))
(defmacro hello [x]
(str "Hello, " x))
@ -25,21 +23,20 @@
(r-infix ~first-arg)
(r-infix ~others)))))
(meditations
"Macros are like functions created at compile time"
; "Macros are like functions created at compile time"
(= __ (hello "Macros!"))
"I can haz infix?"
; "I can haz infix?"
(= __ (infix (9 + 1)))
"Remember, these are nothing but code transformations"
; "Remember, these are nothing but code transformations"
(= __ (macroexpand '(infix (9 + 1))))
"You can do better than that - hand crafting FTW!"
; "You can do better than that - hand crafting FTW!"
(= __ (macroexpand '(infix-better (10 * 2))))
"Things don't always work as you would like them to... "
; "Things don't always work as you would like them to... "
(= __ (macroexpand '(infix-better ( 10 + (2 * 3)))))
"Really, you don't understand recursion until you understand recursion"
(= 36 (r-infix (10 + (2 * 3) + (4 * 5)))))
; "Really, you don't understand recursion until you understand recursion"
(= 36 (r-infix (10 + (2 * 3) + (4 * 5))))

38
19_datatypes.clj
View file

@ -1,47 +1,25 @@
(ns koans.19-datatypes
(:require [koan-engine.core :refer :all]))
(defrecord Nobel [prize])
(deftype Pulitzer [prize])
(defprotocol Award
(present [this recipient]))
(defrecord Oscar [category]
Award
(present [this recipient]
(print (str "Congratulations on your "
(:category this) " Oscar, "
recipient
"!"))))
(deftype Razzie [category]
Award
(present [this recipient]
__))
(meditations
"Holding records is meaningful only when the record is worthy of you"
; "Holding records is meaningful only when the record is worthy of you"
(= __ (.prize (Nobel. "peace")))
"Types are quite similar"
; "Types are quite similar"
(= __ (.prize (Pulitzer. "literature")))
"Records may be treated like maps"
; "Records may be treated like maps"
(= __ (:prize (Nobel. "physics")))
"While types may not"
; "While types may not"
(= __ (:prize (Pulitzer. "poetry")))
"Further study reveals why"
; "Further study reveals why"
(= __
(map map? [(Nobel. "chemistry")
(Pulitzer. "music")]))
"Either sort of datatype can define methods in a protocol"
; "Either sort of datatype can define methods in a protocol"
(= __
(with-out-str (present (Oscar. "Best Picture") "Evil Alien Conquerors")))
"Surely we can implement our own by now"
; "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")))

15
20_java_interop.clj
View file

@ -1,19 +1,16 @@
(ns koans.20-java-interop
(:require [koan-engine.core :refer :all]))
(meditations
"You may have done more with Java than you know"
; "You may have done more with Java than you know"
(= __ (class "warfare")) ; hint: try typing (javadoc "warfare") in the REPL
"The dot signifies easy and direct Java interoperation"
; "The dot signifies easy and direct Java interoperation"
(= __ (.toUpperCase "select * from"))
"But instance method calls are very different from normal functions"
; "But instance method calls are very different from normal functions"
(= ["SELECT" "FROM" "WHERE"] (map ___ ["select" "from" "where"]))
"Constructing might be harder than breaking"
; "Constructing might be harder than breaking"
(= 10 (let [latch (java.util.concurrent.CountDownLatch. __)]
(.getCount latch)))
"Static methods are slashing prices!"
(== __ (Math/pow 2 10)))
; "Static methods are slashing prices!"
(== __ (Math/pow 2 10))

17
21_partition.clj
View file

@ -1,21 +1,18 @@
(ns koans.21-partition
(:require [koan-engine.core :refer :all]))
(meditations
"To split a collection you can use the partition function"
; "To split a collection you can use the partition function"
(= '((0 1) (2 3)) (__ 2 (range 4)))
"But watch out if there are not enough elements to form n sequences"
; "But watch out if there are not enough elements to form n sequences"
(= '(__) (partition 3 [:a :b :c :d :e]))
"You can use partition-all to include any leftovers too"
; "You can use partition-all to include any leftovers too"
(= __ (partition-all 3 (range 5)))
"If you need to, you can start each sequence with an offset"
; "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)))
"Consider padding the last sequence with some default values..."
; "Consider padding the last sequence with some default values..."
(= '((0 1 2) (3 4 5) (6 :hello)) (partition 3 3 [__] (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))))
; "... 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)))

19
22_group_by.clj
View file

@ -1,26 +1,19 @@
(ns koans.22-group-by
(:require [koan-engine.core :refer :all]))
(defn get-odds-and-evens [coll]
(let [{odds true evens false} (group-by __ coll)]
[odds evens]))
(meditations
"To categorize a collection by some function, use group-by."
; "To categorize a collection by some function, use group-by."
(= __ (group-by count ["hello" "world" "foo" "bar"]))
"You can simulate filter + remove in one pass"
; "You can simulate filter + remove in one pass"
(= (get-odds-and-evens [1 2 3 4 5])
((juxt filter remove) odd? [1 2 3 4 5])
[[1 3 5] [2 4]])
"You can also group by a primary key"
; "You can also group by a primary key"
(= __
(group-by :id [{:id 1 :name "Bob"}
{:id 2 :name "Jennifer"}
{:id 1 :last-name "Smith"} ]))
"But be careful when you group by a non-required key"
; "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}]}
@ -28,9 +21,9 @@
{:id 2 :name "Jennifer"}
{:id 1 :last-name "Smith"}]))
"The true power of group-by comes with custom functions"
; "The true power of group-by comes with custom functions"
(= __
(group-by #(if (:bad %) :naughty-list :nice-list)
[{:name "Jimmy" :bad true}
{:name "Jane" :bad false}
{:name "Joe" :bad true}])))
{:name "Joe" :bad true}]))

29
23_meta.clj
View file

@ -1,18 +1,11 @@
(ns koans.23-meta
(:require [koan-engine.core :refer :all]))
(def giants
(with-meta 'Giants
{:league "National League"}))
(meditations
"Some objects can be tagged using the with-meta function"
; "Some objects can be tagged using the with-meta function"
(= __ (meta giants))
"Or more succinctly with a reader macro"
; "Or more succinctly with a reader macro"
(= __ (meta '^{:division "West"} Giants))
"While others can't"
; "While others can't"
(= __ (try
(with-meta
2
@ -20,18 +13,18 @@
(catch ClassCastException e
"This doesn't implement the IObj interface")))
"Notice when metadata carries over"
; "Notice when metadata carries over"
(= __ (meta (merge '^{:foo :bar} {:a 1 :b 2}
{:b 3 :c 4})))
"And when it doesn't"
; "And when it doesn't"
(= __ (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"
; "Metadata can be used as a type hint to avoid reflection during runtime"
(= __ (#(.charAt ^String % 0) "Cast me"))
"You can directly update an object's metadata"
; "You can directly update an object's metadata"
(= 8 (let [giants
(with-meta
'Giants
@ -39,13 +32,13 @@
(swap! (:world-series-titles (meta giants)) __)
@(:world-series-titles (meta giants))))
"You can also create a new object from another object with metadata"
; "You can also create a new object from another object with metadata"
(= {:league "National League" :park "AT&T Park"}
(meta (vary-meta giants
assoc __ __)))
"But it won't affect behavior like equality"
; "But it won't affect behavior like equality"
(= __ (vary-meta giants dissoc :league))
"Or the object's printed representation"
(= __ (pr-str (vary-meta giants dissoc :league))))
; "Or the object's printed representation"
(= __ (pr-str (vary-meta giants dissoc :league)))