Kata: Bowling Game in Clojure

I've just done the Bowling Game Kata in Clojure.

These are the tests using Midje:

	(ns bowling-game.core-test
	(:use midje.sweet)
	(:use [bowling-game.core]))
	(def a-gutter-game (repeat 20 0))
	(def a-no-spares-no-strikes-game
	(concat [1 6 4 5 3 1] (repeat 14 0)))
	(def a-game-with-spares
	(concat [4 6 4 5 3 1] (repeat 14 0)))
	(def a-game-with-strikes
	(concat [10 4 5 3 1] (repeat 14 0)))
	(def a-game-with-spare-in-10th-frame
	(concat (repeat 14 0) [3 1 4 2 4 6] [2]))
	(def a-game-with-strike-in-10th-frame
	(concat (repeat 14 0) [3 1 4 2 10] [2 3]))
	(def a-perfect-game
	(repeat 12 10))
	(facts "about bowling-game"
	(fact "it scores a game with no spins down"
	(score a-gutter-game) => 0)
	(fact "it scores a game with neither spares nor strikes"
	(score a-no-spares-no-strikes-game) => 20)
	(fact "it scores a game with a spare"
	(score a-game-with-spares) => 27)
	(fact "it scores a game with a strike"
	(score a-game-with-strikes) => 32)
	(fact "it scores a game with a spare in the 10th frame"
	(score a-game-with-spare-in-10th-frame) => 22)
	(fact "it scores a game with a strike in the 10th frame"
	(score a-game-with-strike-in-10th-frame) => 25)
	(fact "it scores a perfect game"
	(score a-perfect-game) => 300))

view raw bowling-game-tests.clj hosted with ❤ by GitHub

and this is the code:

	(ns bowling-game.core)
	(defn- points [rolls]
	(reduce + rolls))
	(def ^:private ten-points?
	(comp (partial = 10) points))
	(def ^:private strike?
	(comp ten-points? (partial take 1)))
	(def ^:private spare?
	(comp ten-points? (partial take 2)))
	(defn- get-rolls-using [get-fn rolls]
	(if (strike? rolls)
	(get-fn 1 rolls)
	(get-fn 2 rolls)))
	(defn- first-frame [rolls]
	(get-rolls-using take rolls))
	(defn- rest-frames [rolls]
	(get-rolls-using drop rolls))
	(defn- take-next [n rolls]
	(drop n (take 3 rolls)))
	(defn- bonus-rolls [rolls]
	(cond (strike? rolls) (take-next 1 rolls)
	(spare? rolls) (take-next 2 rolls)
	:else (empty rolls)))
	(defn- score-current-frame [rolls n]
	(if (> n 10)
	0
	(+ (points (first-frame rolls))
	(points (bonus-rolls rolls)))))
	(defn- score-frames [rolls n]
	(if (empty? rolls)
	0
	(+ (score-current-frame rolls n)
	(score-frames (rest-frames rolls) (inc n)))))
	(defn score [rolls]
	(score-frames rolls 1))

view raw bowling-game.clj hosted with ❤ by GitHub

I used a mix of TDD and REPL-driven development to solve it.

I commited the code after every passing test, every refactor and every major REPL spike.

If you want to follow the process, you can find the commits step by step here.

You can find the resulting code in GitHub.