CODEWITHSUNDEEP
pythontail-recursiontail-call-optimization
Jason Baker
Jason Baker

Reputation: 198837

What's the big deal with tail-call optimization and why does Python need it?

Apparently, there's been a big brouhaha over whether or not Python needs tail-call optimization (TCO). 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, what would be a snippet of code that would be greatly simplified using TCO?

Upvotes: 20

Views: 1923

Answers (4)

Javier
Javier

Reputation: 62681

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). In minimalistic languages you get huge expressive power without sacrificing performance.

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

Upvotes: 16

Zifre
Zifre

Reputation: 27008

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.

Upvotes: 5

barracel
barracel

Reputation: 1829

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.

Upvotes: 0

Alex Martelli
Alex Martelli

Reputation: 882721

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).

Upvotes: 6

Related Questions