Kata: Numbers Spelling in Clojure

I've just done the Numbers Spelling kata in Clojure:

These are the tests using Midje:

	(ns number-spelling.core-test
	(:use midje.sweet)
	(:use [number-spelling.core]))
	(facts
	"about number-spelling"
	(fact
	"it can spell out one-digit numbers"
	(spell-out 0) => "zero"
	(spell-out 1) => "one"
	(spell-out 9) => "nine")
	(fact
	"it can spell out two-digit numbers"
	(spell-out 10) => "ten"
	(spell-out 11) => "eleven"
	(spell-out 19) => "nineteen"
	(spell-out 20) => "twenty"
	(spell-out 21) => "twenty one"
	(spell-out 30) => "thirty"
	(spell-out 39) => "thirty nine"
	(spell-out 95) => "ninety five")
	(fact
	"it can spell out three-digit numbers"
	(spell-out 100) => "one hundred"
	(spell-out 103) => "one hundred and three"
	(spell-out 199) => "one hundred and ninety nine"
	(spell-out 999) => "nine hundred and ninety nine")
	(fact
	"it can spell out four-digit numbers"
	(spell-out 1000) => "one thousand"
	(spell-out 1501) => "one thousand, five hundred and one"
	(spell-out 9000) => "nine thousand"
	(spell-out 9999) => "nine thousand, nine hundred and ninety nine")
	(fact
	"it can spell out five-digit numbers"
	(spell-out 21501) => "twenty one thousand, five hundred and one"
	(spell-out 99999) =>
	"ninety nine thousand, nine hundred and ninety nine")
	(fact
	"it can spell out six-digit numbers"
	(spell-out 999999) =>
	"nine hundred and ninety nine thousand, nine hundred and ninety nine")
	(fact
	"it can spell out seven-digit numbers"
	(spell-out 9999999) =>
	"nine million, nine hundred and ninety nine thousand, nine hundred and ninety nine")
	(fact
	"it can spell out eight-digit numbers"
	(spell-out 99999999) =>
	"ninety nine million, nine hundred and ninety nine thousand, nine hundred and ninety nine")
	(fact
	"it can spell out nine-digit numbers"
	(spell-out 999999999) =>
	"nine hundred and ninety nine million, nine hundred and ninety nine thousand, nine hundred and ninety nine")
	(fact
	"it can spell out ten-digit numbers"
	(spell-out 9999999999) =>
	"nine billion, nine hundred and ninety nine million, nine hundred and ninety nine thousand, nine hundred and ninety nine")
	(fact
	"it can spell out a lot of billions!"
	(spell-out 9999999999999) =>
	"nine thousand, nine hundred and ninety nine billion, nine hundred and ninety nine million, nine hundred and ninety nine thousand, nine hundred and ninety nine"))

view raw numbers-spelling-tests.clj hosted with ❤ by GitHub

and this is the code:

	(ns number-spelling.core)
	(declare
	one-word-numbers
	num-digits
	pow
	spell-out-number-over-99
	spell-out-number-up-to-99)
	(defn spell-out [number]
	(cond
	(> (num-digits number) 9)
	(spell-out-number-over-99 number 9 " billion" ", ")
	(> (num-digits number) 6)
	(spell-out-number-over-99 number 6 " million" ", ")
	(> (num-digits number) 3)
	(spell-out-number-over-99 number 3 " thousand" ", ")
	(> (num-digits number) 2)
	(spell-out-number-over-99 number 2 " hundred" " and ")
	:else
	(spell-out-number-up-to-99 number)))
	(defn- spell-out-number-over-99 [number digits separator1 separator2]
	(let [power-of-ten (pow 10 digits)
	over-power-of-ten (rem number power-of-ten)]
	(str (spell-out (quot number power-of-ten))
	separator1
	(if (zero? over-power-of-ten)
	""
	(str separator2 (spell-out over-power-of-ten))))))
	(defn- spell-out-number-up-to-99 [number]
	(if-let [one-word-number (get one-word-numbers number)]
	one-word-number
	(str (spell-out (* (quot number 10) 10))
	(if (zero? (rem number 10))
	""
	(str " " (spell-out (rem number 10)))))))
	(defn- pow [base exp]
	(reduce * (repeat exp base)))
	(def ^:private one-word-numbers
	{0 "zero"
	1 "one"
	2 "two"
	3 "three"
	4 "four"
	5 "five"
	6 "six"
	7 "seven"
	8 "eight"
	9 "nine"
	10 "ten"
	11 "eleven"
	12 "twelve"
	13 "thirteen"
	14 "fourteen"
	15 "fifteen"
	16 "sixteen"
	17 "seventeen"
	18 "eightteen"
	19 "nineteen"
	20 "twenty"
	30 "thirty"
	40 "forty"
	50 "fifty"
	60 "sixty"
	70 "seventy"
	80 "eighty"
	90 "ninety"})
	(defn- num-digits [number]
	(count (str number)))

view raw numbers-spelling.clj hosted with ❤ by GitHub

To document the TDD process I commited the code after every passing test and every refactor. You can find the commits step by step here.

If you look at the commits, you'll notice that it took me some time to find a simple algorithm using TDD but once I found it I could simplify the code quite a bit.

You can find the code in this repository in GitHub.