Before coming to exercises 7.8 – 7.10 let us discuss the find-if operator first. Find-if takes a predicate and a list as input and ‘returns’ the first element matching the predicate. (Why ‘returns’? Because functions always evaluate to something, they don’t give you back. Looks like it’s the same, but Lisp / Clojure gets easier when you think of evaluating functions whenever you see a pair of brackets.) So,
|
1 2 |
(find-if #'oddp '(2 4 6 7 8 9)) ;7 |
Of course, a lambda expression as predicate is possible, too:
|
1 2 3 4 |
(find-if #'(lambda (x) (> x 3)) '(2 4 6 7 8 9)) ;4 |
There’s no such thing as find-if in Clojure! Clojure uses the more generic filter function instead. So we can define our own simple find-if with this little function:
|
1 2 3 |
(defn find-first [f coll] (first (filter f coll))) |
Calls this function like this:
|
1 2 |
(find-first even? '(1 3 5 6 7)) ; 6 |
…and find-first finds you the first even element of the input collection. filter takes f (here: the even? predicate) as input and applies it to the collection ‘(1 3 5 6 7). This evaluates to the list (6). Take the first element of it and you get 6. Not that difficult, is it?
Exercise 7.8 asks for a function with two inputs x (a list) and k (a value), that returns the first number in the list that is roughly equal to k (that means k-10 < number < k+10). Exercise 7.9 makes you write find-nested that returns the first element of a list that is itself a non-nil list.
Let us first care about these exercises before proceeding to exercise 7.10.
This is the Lisp code for these exercises:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
;;; ex 7.8 (defun roughly-equal (x k) "x list, k a number. Return the value in x that's close to k (between -10 and 10)." ;; call is: (roughly-equal '(10 20 30 40) 33) (find-if #'(lambda (e) (and (>= e (- k 10)) (<= e (+ k 10)))) x)) ;;; ex 7.9 (defun find-nested (x) "returns the first element of a list that is itself a non-NIL list" (find-if #'(lambda (e) (not (null e))) x)) |
And this is the same code in Clojure:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
;;; ex 7.8 (defn find-first [f coll] (first (filter f coll))) (defn roughly-equal "x list, k a number. Return the value in x that's close to k (between -10 and 10)." ;; call is: (roughly-equal '(10 20 30 40) 33) [x k] (first (filter (fn [e] (and (>= e (- k 10)) (<= e (+ k 10)))) x))) ;;; ex 7.9 (defn find-nested "returns the first element of a list that is itself an unempty list" [x] (first (filter (fn [e] (not (empty? e))) x))) |
Note the differences: both roughly-equal versions are using lambda expressions in their appropriate dialect. These are applied to find-if (Lisp) and filter (Clojure), respectively. Note the extra first in the Clojure expression due to filter returning a list.
find-nested in both dialects also has similar differences and similarities. A list that is not empty is “not null” in Lisp and “not empty?” in Clojure, but the basic mechanism is the same in both functions. The applicative operator takes a function / predicate / lambda expression and a list as input. Each element e of the input list x wanders through the predicate and is tested for emptiness. The first match is returned.
Exercise 7.10 is a “mini keyboard exercise”. That is a more complex program consisting of cohering functions, here: a program to transpose a song from one key to another.
Exercise 7.10.a: Write a table for the correspondence between notes and numbers for a one-octave scale.
Exercise 7.10.b: Write a function numbers that takes an input list of notes and returns its corresponding numbers.
Exercise 7.10.c: Write a function notes that works the other way round.
Exercise 7.10.d is a comprehension question. Exercise 7.10.e makes you write the function raise that takes a number n and a list of numbers as input and raises each number in the list by the value n.
Exercise 7.10.f asks for a function normalize that takes a list of numbers as input and normalizes then to make them be between 1 and 12.
Exercise 7.10.g makes you write transpose, a function that takes a number n and a song as input, and that returns the song transposed by n half steps.
I’ve just summarized the tasks here; if you want to work through the exercises I really recommend downloading Touretzky’s book here (the edition from 1990). It’s free (and legal). Or buy the book and support Dover Publications.
This is the Lisp code:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
;;; ex 7.10 ;;; a (defparameter note-table '((c 1) (c-sharp 2) (d 3) (d-sharp 4) (e 5) (f 6) (f-sharp 7) (g 8) (g-sharp 9) (a 10) (a-sharp 11) (b 12))) ;;; b (defun numbers (notes) (mapcar #'(lambda (note) (second (assoc note note-table))) notes)) ;;; c (defun notes (nums) (let ((revnotetable (mapcar #'reverse note-table))) (mapcar #'(lambda (number) (second (assoc number revnotetable))) nums))) ;;; e (defun raise (factor numbers) (mapcar #'(lambda (note) (+ factor note)) numbers)) ;;; f (defun normalize (numbers) (mapcar #'(lambda (note) (cond ((= note 12) 12) (t (mod note 12)))) numbers)) ;;; g (defun transpose (number song) (notes (normalize (raise number (numbers song))))) ;; call with: (transpose 5 '(e d c d e e e)) |
And this is the Clojure version:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
;;; ex 7.10 ;;; a (def note-map { :c 1 :c-sharp 2 :d 3 :d-sharp 4 :e 5 :f 6 :f-sharp 7 :g 8 :g-sharp 9 :a 10 :a-sharp 11 :b 12}) ;;; b (defn numbers [notes] ;; call: (numbers '(:c :d :e)) (map (fn [note] (get note-map note)) notes)) ;;; c (defn notes [nums] ;; call (notes (numbers '(:c :d :e))) (let [revnotemap (clojure.set/map-invert note-map)] ; only if vals are distinct from each other (map (fn [number] (get revnotemap number)) nums))) ;;; e (defn raise ;; call: (raise 5 '(5 3 1 4 5 5 5)) [factor numbers] (map (fn [note] (+ factor note)) numbers)) ;;; f (defn normalize [numbers] ;; call (normalize '(6 10 13)) (map (fn [note] (cond (= note 12) 12 :else (mod note 12))) numbers)) ;;; g (defn transpose [number song] ;; call with: (transpose 5 '(:e :d :c :d :e :e :e)) (notes (normalize (raise number (numbers song))))) |
The differences start already in the beginning, because there are no association lists in Clojure. We take something better: a map. Every note is a key with its matching number as value. This has some influence on function calls. While it’s
|
1 |
(numbers '(c d e)) |
in Lisp, the Clojure call looks like this:
|
1 |
(numbers '(:c :d :e)) |
Accessing Lisp’s members of association lists is done with functions like assoc; the same is done with get on Clojure’s maps. Apart from that you will recognize most of Lisp’s code in its modern cousin language. The different data structures are the main difference; everything else is just syntax.
