Explain to me what the big deal with tail call opt

Question

So apparently, there's been a big brouhaha over whether or not Python needs tail call optimization. This came to a head when someone shipped Guido a copy of SICP because he didn't "get it." I'm in the same boat as Guido. I understand the concept of tail call optimization. I just can't think of any reason why Python really needs it.

To make this easier for me to understand, could someone give me a snippet of code that would be greatly simplified using TCO?

Answer 1

If you intensely want to use recursion for things that might alternatively be expressed as loops, then "tail call optimization" is really a must. However, Guido, Python's Benevolent Dictator For Life (BDFL), strongly believes in loops being expressed as loops -- so he's not going to special-case tail calls (sacrificing stack-trace dumps and debugging regularity).

Answer 2

Tail call optimization makes it easier to write recursive functions without worrying about a stack overflow:

def fac(n, result=1):
        if n > 1:
                return fac(n - 1, n * result)
        return result

Without tail call optimization, calling this with a big number could overflow the stack.

Answer 3

I have been thinking to your question for years (believe it or not...). I was so deeply invested in this question that I finally wrote a whole article (which is also a presentation of one of my modules I wrote some months ago without taking the time to write a precise explanation of how to do it). If you are still interested in that question, please read my answer on my blog. In two words, I give a presentation of the tco module; you will not find anything that you can't already do without tail-recursion elimination, but you may be interested by my thoughts about it.

I know that mere links are not the preferred usage on Stackoverflow; please consider however that I wrote a whole article for answering to this post (which I refer to in the body of my article) including also some pictures for illustrating it. For this reason, I post here this unusual answer.

Answer 4

Guido recognized in a follow up post that TCO allowed a cleaner the implementation of state machine as a collection of functions recursively calling each other. However in the same post he proposes an alternative equally cleaner solution without TCO.

Answer 5

Personally, i put great value on tail call optimization; but mainly because it makes recursion as efficient as iteration (or makes iteration a subset of recursion). On minimalistic languages you get huge expressive power without sacrificing performance.

On a 'practical' language (like Python), OTOH, you usually have a lot of other constructions for almost every situation imaginable, so it's less critical. Always a good thing to have, to allow for unforeseen situations, of course