Clojure Koans 9 Higher Order Functions Notebook

{:hello (clojure-version)}

;; "The map function relates a sequence to another"

(= [4 8 12] (map (fn [x] (* 4 x)) [1 2 3]))

;; description: An anonymous function (which multiplies something by four) is mapped over the vector "one two three." This mapping results in a new vector of "four eight twelve".

;; skill 9001: Map a function over a sequence to transform/change/mutate the sequence

;; "You may create that mapping"

(= [1 4 9 16 25] (map (fn [x] (* x x)) [1 2 3 4 5]))

;; skill 9002: Write an inline function to be passed to a mapping higher-order function

;; "Or use the names of existing functions"

(= [false false true false false] (map nil? [:a :b nil :c :d]))

;; skill 9003: Pass an existing function to a mapping function 

;; "A filter can be strong"

(= '() (filter (fn [x] false) '(:anything :goes :here)))

;; question 9001: What is a "strong" filter?

;; "Or very weak"

(= '(:anything :goes :here) (filter (fn [x] true) '(:anything :goes :here)))

;; question 9002: What is a "weak" filter?

;; "Or somewhere in between"

(= [10 20 30] (filter (fn [x] (< x 40)) [10 20 30 40 50 60 70 80]))

;; skill 9004: Filter a vector/collection with a boolean condition

;; "Maps and filters may be combined"

(= [10 20 30] (map (fn [x] (* x 10)) (filter (fn [x] (< x 4)) [1 2 3 4 5 6 7 8])))

;; skill 9005: Filter over a vector/collection and then map over it with a transformation function

;; "Reducing can increase the result"

(= 24 (reduce (fn [a b] (* a b)) [1 2 3 4]))

;; skill 9006: Reduce a vector/collection of numbers by multiplying them together

;; "You can start somewhere else"

(= 2400 (reduce (fn [a b] (* a b)) 100 [1 2 3 4]))

;; description: An "a times b" function is used to reduce over the vector "one two three four" where the initial accumulator value is 100. This reduction results in a result of 2400 (* 100 1 2 3 4).

;; skill 9007: Reduce with a programmer-supplied initial value/accumulator

;; "Numbers are not the only things one can reduce"

(= "longest" (reduce (fn [a b]

                        (if (< (count a) (count b)) b a))

                      ["which" "word" "is" "longest"]))

;; exercise 9001: Determine the longest word in a vector by supplying a custom compare function to reduce