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

Merge ead7f24c06 into b31227c0a8

Browse source
This commit is contained in:
Artur Meyster 2016-08-08 17:33:58 +00:00 committed by GitHub
commit b6ecd8a6ec
7 changed files with 86 additions and 86 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/koans/01_equalities.clj
View file

@ -3,37 +3,37 @@
(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)
"When things cannot be equal, they must be different"
(not= :fill-in-the-blank __))
(not= :fill-in-the-blank :not-equal))

44
src/koans/02_strings.clj
View file

@ -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 occurence 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? "string"))
"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?")))

24
src/koans/03_lists.clj
View file

@ -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!"))))

20
src/koans/04_vectors.clj
View file

@ -3,31 +3,31 @@
(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)))

12
src/koans/05_sets.clj
View file

@ -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})))

30
src/koans/06_maps.clj
View file

@ -3,48 +3,48 @@
(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))
"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"}))))

20
src/koans/07_functions.clj
View file

@ -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"
(= __ (#(* 15 %2) 1 2))
(= 30 (#(* 15 %2) 1 2))
"One function can beget another"
(= 9 (((fn [] ___)) 4 5))
(= 9 ((#(fn [a b] (+ a b))) 4 5))
"Functions can also take other functions as input"
(= 20 ((fn [f] (f 4 5))
___))
*))
"Higher-order functions take function arguments"
(= 25 (___
(= 25 ((fn [aFun] (aFun 5))
(fn [n] (* n n))))
"But they are often better written using the names of functions"
(= 25 (___ square)))
(= 25 ((fn [squre] (squre 5)) square)))