Question

How do LISPs or MLs implement tail-call optimization?

Answer 1

I can’t speak on the exact implementation details different compilers/interpreters, however generally speaking tail-call optimization operates like this:

Normally a function call involves something like this:

1. Allocate stack space for the return
2. Push your current instruction pointer onto the stack
3. Allocate stack space for the function parameters and set them appropriately
4. Call your function
5. To return it sets it’s return space appropriately, pops off the instruction pointer it should be returning to and jumps to it

However when a function is in tail position, which pretty much means you are returning the result of the function you are about to call, you can be tricky and do

1. Re-use the stack space allocated for your own return value as the stack space allocated for the return value of the function you are about to call
2. Re-use the instruction pointer you should be returning to as the instruction pointer that the function you are about to call will use
3. Free your own parameters stack space
4. Allocate space for the parameters and set appropriately
5. Set the value of your parameters
6. Call your function
7. When it returns, it will be returning directly to your caller.

Note that #1 and #2 don’t actually involve any work, #3 can be tricky or simple depending on your implementation, and 4-7 don’t involve anything special from the function you are calling. Also note that all of this results in a 0 stack growth with respect to your call stack, so this allows for infinte recursion and generally speeding things up a little.

Also note that this kind of optimization can be applied not only to directly recursive functions, but co-recursive functions and in fact all calls that are in tail position.