Bizarre factorial in Clojure

I'm reading Brian Marick's Functional Programming for the Object-Oriented Programmer book.

This is my solution for an exercise from the first chapter, Just Enough Clojure in which I had to write a "bizarre version of factorial that uses neither iteration nor recursion":

	(defn bizarre-factorial [n]
	(apply * (range 1 (+ n 1))))

view raw bizarre-factorial-ints.clj hosted with ❤ by GitHub

Tested at the REPL it seems to work fine:

	user=> (bizarre-factorial 1)
	1
	user=> (bizarre-factorial 2)
	2
	user=> (bizarre-factorial 3)
	6
	user=> (bizarre-factorial 4)
	24
	user=> (bizarre-factorial 5)
	120
	user=> (bizarre-factorial 6)
	720
	user=> (bizarre-factorial 7)
	5040
	user=> (bizarre-factorial 10)
	3628800

view raw bizarre-fact-repl-1.sh hosted with ❤ by GitHub

However, there are problems for big enough results because they don't fit into integers:

	user=> (bizarre-factorial 40)
	ArithmeticException integer overflow
	clojure.lang.Numbers.throwIntOverflow (Numbers.java:1388)

view raw bizarre-fact-repl5.sh hosted with ❤ by GitHub

This can be easily solved using arbitrary precision integers.
You just need to append an N after any number in the calculation, since it's "contagious" to the rest of the calculation:

	(defn bizarre-factorial [n]
	(apply * (range 1N (+ n 1))))

view raw bizarre-factorial-bigints.clj hosted with ❤ by GitHub

Now it works:

	user=> (bizarre-factorial 40)
	815915283247897734345611269596115894272000000000N
	user=> (bizarre-factorial 100)
	93326215443944152681699238856266700490715968264381621468592963895
	21759999322991560894146397615651828625369792082722375825118521091
	6864000000000000000000000000N

view raw bizarre-fact-repl2.sh hosted with ❤ by GitHub

That's ok but how does bizarre-factorial works?

Let's first examine range function:

	user=> (doc range)
	-------------------------
	clojure.core/range
	([] [end] [start end] [start end step])
	Returns a lazy seq of nums from start (inclusive) to end
	(exclusive), by step, where start defaults to 0, step to 1,
	and end to infinity.
	nil

view raw bizarre-fact-repl3.sh hosted with ❤ by GitHub

So, for example, to get the first 10 positive arbitrary precision integers we'd write:

	user=> (range 1N 11)
	(1N 2N 3N 4N 5N 6N 7N 8N 9N 10N)

view raw bizarre-fact-repl4.sh hosted with ❤ by GitHub

We might refactor bizarre-factorial using let to create a helper function, positive-ints-until, to make this more explicit:

	(defn bizarre-factorial [n]
	(let [positive-ints-until (fn [n] (range 1N (+ n 1)))]
	(apply * (positive-ints-until n))))

view raw bizarre-factorial-with-helper.clj hosted with ❤ by GitHub

Let's see now how apply works:

	user=> (doc apply)
	-------------------------
	clojure.core/apply
	([f args] [f x args] [f x y args] [f x y z args] [f a b c d & args])
	Applies fn f to the argument list formed by prepending
	intervening arguments to args.
	nil

view raw bizarre-fact-repl5.sh hosted with ❤ by GitHub

So in the case of bizarre-factorial the apply function is applying the * function to a list of numbers returned by the positive-ints-until helper function.

That's how bizarre-factorial works.

Finally we can use partial to give a better name to the partial application of apply and *:

	(defn bizarre-factorial [n]
	(let [positive-ints-until (fn [n] (range 1N (+ n 1)))
	multiply (partial apply *)]
	(multiply (positive-ints-until n))))

view raw bizarre-fact-with-partial.clj hosted with ❤ by GitHub

This version of bizarre-factorial is much more readable.