This post describes my first experience with doing the FizzBuzz kata in Clojure.

After having looked at Clojure for some time, I finally had a bit of time to play with it, so I decided to do the FizzBuzz kata in Clojure.

### Single fizzbuzz function #

Clojure has a built-in testing framework, so I wrote a Parameterized Test for a single fizzbuzz function. Using TDD, I added test cases a little at a time, attempting to follow the Transformation Priority Premise, but the end result is this:

```(ns fizzbuzz.core-test
(:use clojure.test
fizzbuzz.core))

(deftest fizzbuzz-test
(are [expected i] (= expected (fizzbuzz i))
"1" 1
"2" 2
"Fizz" 3
"4" 4
"Buzz" 5
"Fizz" 6
"7" 7
"8" 8
"Fizz" 9
"Buzz" 10
"11" 11
"Fizz" 12
"13" 13
"14" 14
"FizzBuzz" 15
"FizzBuzz" 30))```

Clojure syntax is somewhat backwards from what I'm normally used to, but the are macro expands into a collection of tests that each evaluate whether the result of invoking the fizzbuzz function with `i` is equal to `expected`.

Through a series of transformations of the SUT, I ended up with this implementation of the fizzbuzz function:

```(ns fizzbuzz.core)

(defn fizzbuzz [i]
(cond
(= 0 (mod i 15)) "FizzBuzz"
(= 0 (mod i 3)) "Fizz"
(= 0 (mod i 5)) "Buzz"
:else (str i)))```

This defines a function called fizzbuzz taking a single argument `i`. The cond macro evaluates each test and returns the expression associated with the first test that evauluates to true. The first test checks if `i` is divisible with 15 and returns "FizzBuzz" if this is the case; the next test checks if `i` is divisible with 3 and returns "Fizz" if this is true, and so on.

### Printing a range of fizzbuzz values #

The task defined by the kata is to print all FizzBuzz values from 1 to 100, so the above function is't the final solution. The next step I took was to write a test that defines a version of the fizzbuzz function taking two parameters:

```(def acceptance-expected
"1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
Fizz
22
23
Fizz
Buzz
26
Fizz
28
29
FizzBuzz
31
32
Fizz
34
Buzz
Fizz
37
38
Fizz
Buzz
41
Fizz
43
44
FizzBuzz
46
47
Fizz
49
Buzz
Fizz
52
53
Fizz
Buzz
56
Fizz
58
59
FizzBuzz
61
62
Fizz
64
Buzz
Fizz
67
68
Fizz
Buzz
71
Fizz
73
74
FizzBuzz
76
77
Fizz
79
Buzz
Fizz
82
83
Fizz
Buzz
86
Fizz
88
89
FizzBuzz
91
92
Fizz
94
Buzz
Fizz
97
98
Fizz
Buzz")

(deftest acceptance-test
(is (= acceptance-expected (fizzbuzz 1 101))))```

I decided to define the `acceptance-expected` value outside of the test case itself, as I thought that made the test a bit more readable. The test case is defined by the is macro and states that the expected value is `acceptance-expected` and the actual value is the result of invoking the fizzbuzz function with two arguments: 1 as the (inclusive) start value, and 101 as the (exclusive) end value. The above code listing of fizzbuzz only accept one argument, but the new test case requires two arguments, so I added an overload to the function:

```(defn fizzbuzz
([i]
(cond
(= 0 (mod i 15)) "FizzBuzz"
(= 0 (mod i 3)) "Fizz"
(= 0 (mod i 5)) "Buzz"
:else (str i)))
([start end]
(apply str
(interpose "\n"
(map fizzbuzz (range start end))))))```

The previous implementation is still there, now contained within the overload taking a single argument `i`, but now there's also a new overload taking two arguments: `start` and `end`.

This overload generates a sequence of integers from `start` to `end` using the range function. It then maps that sequence of integers into a sequence of strings by mapping each integer to a string with the fizzbuzz function. That gives you a sequence of strings such as `("1" "2" "Fizz" "4" "Buzz")`.

In order to print all the FizzBuzz strings, I need to interpose a newline character between each string, which produces a new sequence of strings such as `("1" "\n" "2" "\n" "Fizz" "\n" "4" "\n" "Buzz")`. To concatenate all these strings, I apply the str function to the sequence.

### Printing FizzBuzz values from 1 to 100 #

The requirements of the kata is to print all FizzBuzz values from 1 to 100, and the code already does this. However, I interpret the kata as requiring a single function that takes no parameters, so I added an acceptance test case:

```(deftest acceptance-test
(is (= acceptance-expected (fizzbuzz 1 101)))
(is (= acceptance-expected (fizzbuzz))))```

Notice the second test case in the last line of code that invokes the fizzbuzz function without any parameters. It's easily resolved by adding a third overload:

```(defn fizzbuzz
([]
(fizzbuzz 1 101))
([i]
(cond
(= 0 (mod i 15)) "FizzBuzz"
(= 0 (mod i 3)) "Fizz"
(= 0 (mod i 5)) "Buzz"
:else (str i)))
([start end]
(apply str
(interpose "\n"
(map fizzbuzz (range start end))))))```

As you can see, the first overload takes no parameters and simply invokes the previously desribed overload with the `start` and `end` arguments.

FWIW, this entire solution is structurally similar to my implementation of FizzBuzz in F#.

### Wish to comment?

You can add a comment to this post by sending me a pull request. Alternatively, you can discuss this post on Twitter or somewhere else with a permalink. Ping me with the link, and I may respond.

#### Published

Thursday, 11 April 2013 06:20:00 UTC

#### Tags

"Our team wholeheartedly endorses Mark. His expert service provides tremendous value."
Hire me!
Published: Thursday, 11 April 2013 06:20:00 UTC