Practising Clojure sequences using FizzBuzz and REPL Driven Development

I recently blogged about my version of the FizzBuzz kata in Clojure using Midje comparing it with a version I did some time ago in Racket's Advanced Student Language.

Even though both solutions were very similar, doing the kata this time in Clojure was useful to practise with Midje.

To try to get to a different solution for the kata and use the Clojure sequence library, I set myself a constraint:
Instead of mapping just a function on the sequence of numbers, I had to find several transformations that could be mapped one after another on sequences to get the same result.

Since I had to do a lot of trial and error, I prefered to use REPL Driven Development this time.

This was the REPL session to get to the first alternative version (eliminating a lot of errors..):

	user=> (range 1 16)
	(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
	user=> (defn is-multiple-of? [num n]
	#_=> (= 0 (rem n num)))
	#'user/is-multiple-of?
	user=> (def is-multiple-of-3?
	#_=> (partial is-multiple-of? 3))
	#'user/is-multiple-of-3?
	user=> (is-multiple-of-3? 3)
	true
	user=> (is-multiple-of-3? 5)
	false
	user=> (def is-multiple-of-5?
	#_=> (partial is-multiple-of? 5))
	#'user/is-multiple-of-5?
	user=> (is-multiple-of-5? 3)
	false
	user=> (is-multiple-of-5? 5)
	true
	user=> (defn fizz [n s]
	#_=> (if (is-multiple-of-3? n)
	#_=> (str s "Fizz")
	#_=> s))
	#'user/fizz
	user=> (fizz 3 "")
	"Fizz"
	user=> (fizz 4 "")
	""
	user=> (defn buzz [n s]
	#_=> (if (is-multiple-of-5? n)
	#_=> (str s "Buzz")
	#_=> s))
	#'user/buzz
	user=> (buzz 3 "")
	""
	user=> (buzz 5 "")
	"Buzz"
	user=> (map fizz (range 1 16) (repeat 16 ""))
	("" "" "Fizz" "" "" "Fizz" "" "" "Fizz" "" "" "Fizz" "" "" "Fizz")
	user=> (map buzz (range 1 16) (repeat 16 ""))
	("" "" "" "" "Buzz" "" "" "" "" "Buzz" "" "" "" "" "Buzz")
	user=> (map (fn [n s] (if (= s "") (str n) s))
	#_=> (range 1 16)
	#_=> (map buzz (range 1 16) (map fizz (range 1 16) (repeat 16 ""))))
	("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")
	user=> (defn empty-str-to-number [n s]
	#_=> (if (= s "") (str n) s))
	#'user/empty-str-to-number
	user=> (map empty-str-to-number ; <- recursive application of map
	#_=> (range 1 16)
	#_=> (map buzz
	#_=> (range 1 16)
	#_=> (map fizz
	#_=> (range 1 16)
	#_=> (repeat 16 ""))))
	("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")
	user=> (def transformations (list fizz buzz empty-str-to-number))
	#'user/transformations
	user=> (defn transform [functions numbers strings]
	#_=> (if (empty? functions)
	#_=> strings
	#_=> (recur (rest functions) numbers (map (first functions) numbers strings))))
	#'user/transform
	user=> (transform transformations (range 1 16) (repeat 16 ""))
	("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")
	user=> (def a-vec [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15])
	#'user/a-vec
	user=> (transform transformations a-vec (repeat (count a-vec) ""))
	("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")
	user=> (defn fiz-buzz-numbers [coll transformations]
	#_=> (let [transform (fn [functions numbers result]
	#_=> (if (empty? functions)
	#_=> result
	#_=> (recur (rest functions)
	#_=> numbers
	#_=> (map (first functions) numbers result))))]
	#_=> (transform transformations coll (repeat (count coll) ""))))
	#'user/fiz-buzz-numbers
	user=> (fiz-buzz-numbers a-vec transformations)
	("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")

view raw fizzbuzzseqrepl1.clj hosted with ❤ by GitHub

From this REPL session I got this alternative version for fizz-buzz:

	(defn fizz-buzz [coll]
	(let [is-multiple-of? (fn [num n]
	(= 0 (rem n num)))
	is-multiple-of-3? (partial is-multiple-of? 3)
	is-multiple-of-5? (partial is-multiple-of? 5)
	fizz (fn [n s]
	(if (is-multiple-of-3? n)
	(str s "Fizz")
	s))
	buzz (fn [n s]
	(if (is-multiple-of-5? n)
	(str s "Buzz")
	s))
	empty-str-to-number (fn [n s]
	(if (= s "")
	(str n)
	s))
	transformations (list fizz buzz empty-str-to-number)
	transform (fn [functions numbers result]
	(if (empty? functions)
	result
	(recur (rest functions)
	numbers
	(map (first functions) numbers result))))]
	(clojure.string/join
	\space
	(transform transformations coll (repeat (count coll) "")))))

view raw fizzbuzzalternative1.clj hosted with ❤ by GitHub

It's more complicated that the original version but it served me to practise some interesting Clojure features: recur, partial, map and let.

Then I tried a different approach:
Reducing the sequence of transformation functions so that I can map the resulting transformation function on the sequence of numbers.

Again I worked in the REPL first:

	user=> (defn is-multiple-of? [num n]
	#_=> (= 0 (rem n num)))
	#'user/is-multiple-of?
	user=> (def is-multiple-of-3?
	#_=> (partial is-multiple-of? 3))
	#'user/is-multiple-of-3?
	user=> (def is-multiple-of-5?
	#_=> (partial is-multiple-of? 5))
	#'user/is-multiple-of-5?
	user=> (def a-vec [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15])
	#'user/a-vec
	user=> (defn fizz [n s]
	#_=> [n (if (is-multiple-of-3? n)
	#_=> (str s "Fizz")
	#_=> s)])
	#'user/fizz
	user=> (fizz 3 "")
	[3 "Fizz"]
	user=> (defn buzz [[n s]]
	#_=> [n (if (is-multiple-of-5? n)
	#_=> (str s "Buzz")
	#_=> s)])
	#'user/buzz
	user=> (buzz [5 ""])
	[5 "Buzz"]
	user=> (defn empty-str-to-number [[n s]]
	#_=> (if (= s "") (str n) s))
	#'user/empty-str-to-number
	user=> (def t (reduce comp (reverse [fizz buzz empty-str-to-number])))
	#'user/t
	user=> (t 1 "")
	"1"
	user=> (t 3 "")
	"Fizz"
	user=> (t 5 "")
	"Buzz"
	user=> (t 15 "")
	"FizzBuzz"
	user=> (map t a-vec (repeat (count a-vec) ""))
	("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")
	user=> (defn fizz2 [[n s]]
	#_=> [n (if (is-multiple-of-3? n)
	#_=> (str s "Fizz")
	#_=> s)])
	#'user/fizz2
	user=> (fizz2 [3 ""])
	[3 "Fizz"]
	user=> (def t2 (reduce comp (reverse [fizz2 buzz empty-str-to-number])))
	#'user/t2
	user=> (for [n a-vec s [""]] [n s])
	([1 ""] [2 ""] [3 ""] [4 ""] [5 ""] [6 ""] [7 ""] [8 ""] [9 ""] [10 ""] [11 ""] [12 ""] [13 ""] [14 ""] [15 ""])
	user=> (map t2 (for [n a-vec s [""]] [n s]))
	("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")

view raw fizzbuzzseqrepl2.clj hosted with ❤ by GitHub

From this second REPL session I got this other alternative version for fizz-buzz:

	(defn fizz-buzz [coll]
	(let [is-multiple-of? (fn [num n]
	(= 0 (rem n num)))
	is-multiple-of-3? (partial is-multiple-of? 3)
	is-multiple-of-5? (partial is-multiple-of? 5)
	fizz (fn [[n s]]
	[n (if (is-multiple-of-3? n)
	(str s "Fizz")
	s)])
	buzz (fn [[n s]]
	[n (if (is-multiple-of-5? n)
	(str s "Buzz")
	s)])
	empty-str-to-number (fn [[n s]]
	(if (= s "") (str n) s))
	transformations (list fizz buzz empty-str-to-number)]
	(clojure.string/join
	\space
	(map
	(reduce comp (reverse transformations))
	(for [n coll s [""]] [n s])))))

view raw fizzbuzzalternative2.clj hosted with ❤ by GitHub

which is again more complicated than the original version but served me to work with other intersting Clojure's features: reduce, comp and reverse.

After these two versions of FizzBuzz I did a web search to find nicer ways to use the Clojure's sequence library to implement FizzBuzz and I found these two in Rosseta Code that I specially like (I modified them a bit so they return the same that the precious versions):

	(defn fizz-buzz [coll]
	(clojure.string/join
	\space
	(map (fn [n]
	(if-let [fb (seq (concat (when (zero? (mod n 3)) "Fizz")
	(when (zero? (mod n 5)) "Buzz")))]
	(apply str fb)
	(str n)))
	coll)))

view raw fizzbuzzalternative3.clj hosted with ❤ by GitHub

	(defn fizz-buzz [coll]
	(clojure.string/join
	\space
	(map #(let [s (str %2 %3) ]
	(if (seq s)
	s
	(str %)))
	coll
	(cycle [ "" "" "Fizz" ])
	(cycle [ "" "" "" "" "Buzz" ]))))

view raw fizzbuzzalternative4.clj hosted with ❤ by GitHub

These two last versions will serve me to learn about if-let and cycle.

Ok, that was all I got today.

Just to sum up, I think there is a lot you can get from even a simple kata like FizzBuzz if you set yourself some constraints and try different variations.

--------------------------------------------------

PS: You'll find other variations of FizzBuzz kata in these previous posts: this one and this other one.