Kata: Parrot Refactoring in Clojure

I did Emily Bache's Parrot Refactoring Kata again (I did this kata in Java some time ago) but this time in Clojure. This is a very simple kata that is meant to practice the Replace Conditional with Polymorphism refactoring.

This is the initial code of the kata that have to be refactored:

	(ns parrot-refactoring.core)
	(def ^:private load-factor 9.0)
	(def ^:private base-speed 12.0)
	(defn- compute-base-speed-for-voltage [voltage]
	(min 24.0 (* voltage base-speed)))
	(defn speed [parrot]
	(case (:type parrot)
	:european-parrot
	base-speed
	:african-parrot
	(max 0.0 (- base-speed (* load-factor (:num-coconuts parrot))))
	:norwegian-blue-parrot
	(if (:nailed parrot)
	0.0
	(compute-base-speed-for-voltage (:voltage parrot)))
	(throw (Exception. "Should be unreachable!"))))

view raw initial-parrot-refactoring.core.clj hosted with ❤ by GitHub

Since Clojure provides several ways of achieving polymorphism, I did two versions of the kata:

- One using protocols:

	(ns parrot-refactoring.core)
	(def ^:private base-speed 12.0)
	(def ^:private minimum-speed 0.0)
	(defprotocol Parrot
	(speed [this]))
	(defrecord EuropeanParrot []
	Parrot
	(speed [_]
	base-speed))
	(defrecord AfricanParrot [num-coconuts]
	Parrot
	(speed [_]
	(let [load-factor 9.0]
	(max minimum-speed (- base-speed (* load-factor num-coconuts))))))
	(defrecord NorwegiaBlueParrot [voltage]
	Parrot
	(speed [_]
	(let [maximum-speed 24.0]
	(min maximum-speed (* voltage base-speed)))))
	(defrecord NailedNorwegiaBlueParrot []
	Parrot
	(speed [_] minimum-speed))
	(defn european []
	(->EuropeanParrot))
	(defn african [num-coconuts]
	(->AfricanParrot num-coconuts))
	(defn norwegian-blue-parrot [voltage]
	(->NorwegiaBlueParrot voltage))
	(defn nailed-norwegian-blue-parrot []
	(->NailedNorwegiaBlueParrot))

view raw parrot-refactoring-protocols.clj hosted with ❤ by GitHub

This refactoring was a bit more involved than the one I did for the next version, but I managed to get rid of the exception and the resulting tests were more readable.

If you feel like following the refactoring process, check the baby steps in the commits. You can find the code in this GitHub repository.

- And another one using multimethods:

	(ns parrot-refactoring.core)
	(def ^:private base-speed 12.0)
	(def ^:private minimum-speed 0.0)
	(defmulti speed :type)
	(defmethod speed :european-parrot [_]
	base-speed)
	(defmethod speed :african-parrot [{:keys [num-coconuts]}]
	(let [load-factor 9.0]
	(max minimum-speed (- base-speed (* load-factor num-coconuts)))))
	(defmethod speed :norwegian-blue-parrot [{:keys [nailed voltage]}]
	(let [maximum-speed 24.0]
	(if nailed
	minimum-speed
	(min maximum-speed (* voltage base-speed)))))
	(defmethod speed :default [_]
	(throw (Exception. "Should be unreachable!")))

view raw parrot-refactoring-multimethods.clj hosted with ❤ by GitHub

This version is much shorter and the refactoring is less involved than the previous one, but the resulting tests read much worse and the map representing the parrot has many "optional" entries.

Again, check the commits of the refactoring baby steps here, if you feel like following the refactoring process. You can find the code of this second version in this GitHub repository. I'd like to thank Emily Bache for sharing this kata.