Clojure Koans Walkthrough

1. Introduction
2. Lists
3. Vectors
4. Sets
5. Maps
6. Functions
7. Conditionals
8. Higher Order Functions
9. Runtime Polymorphism
10. Lazy Sequences
11. Sequence Comprehensions
12. Creating Functions
13. Recursion
14. Destructuring
15. Refs
16. Atoms
17. Macros
18. Datatypes
19. Java Interop
20. Partition

Recommended Books

• ← Conditionals
• Runtime Polymorphism →

8. Higher Order Functions - Koans Walkthrough

This video covers higher order functions, such as map, reduce and filter.

Here is the 08_higher_order_functions.clj source code:

(meditations
  "The map function relates a sequence to another"
  (= [4 8 12] (map (fn [x] (* 4 x)) [1 2 3]))

  "You may create that mapping"
  (= [1 4 9 16 25] (map (fn [x] (* x x)) [1 2 3 4 5]))

  "Or use the names of existing functions"
  (= [false false true false false] (map nil? [:a :b nil :c :d]))

  "A filter can be strong"
  (= '() (filter (fn [x] false) '(:anything :goes :here)))

  "Or very weak"
  (= (list :anything :goes :here) (filter (fn [x] true) '(:anything :goes :here)))

  "Or somewhere in between"
  (= [10 20 30] (filter (fn [x] (< x 31)) [10 20 30 40 50 60 70 80]))

  "Maps and filters may be combined"
  (= [10 20 30] (map (fn [x] (* 10 x)) (filter (fn [x] (<= x 3)) [1 2 3 4 5 6 7 8])))

  "Reducing can increase the result"
  (= 24 (reduce (fn [a b] (* a b)) [1 2 3 4]))

  "You can start somewhere else"
  (= 2400 (reduce (fn [a b] (* a b)) (conj [1 2 3 4] 100)))

  "Numbers are not the only things one can reduce"
  (= "longest" (reduce (fn [a b]
                         (if (< 0 1) b a))
                       ["which" "word" "is" "longest"])))