I’m working through Stuart Halloway’s 'Programming Clojure' book and I just got to the section where it first mentions recursive functions.

It’s a simple function to countdown from a given number to zero and then return that sequence.

This was one of the examples from the book:

That function could then be called like this:

I wanted to see what the function would look if we didn’t have the empty vector as a parameter.

From playing around with F# and Scala my first thought would be to write the function like this:

As the book points out a bit further on, Clojure doesn’t perform automatic tail call optimisation so we end up with a stack overflow exception if we run the function with a big enough input value.

Clojure does optimise calls to 'recur' so it makes more sense to use that if we want to avoid that problem.

This is an example which makes use of that:

Looking through the Clojure mailing list at a similar problem I noticed that one of the suggestions was to arity overload the function to include an accumulator.

Written this way it feels a little bit like Haskell or Erlang but probably not idiomatic Clojure.

Anyway on the next page Halloway shows a better way to do this with much less code!

I noticed that in Scala the idea of using 'take' and 'drop' on streams of values seems to be quite popular so I’m intrigued as to whether I’ll find the same thing with Clojure.