trampolines

If I understand correctly, scala.util.control.TailCalls can be used to avoid stack overflows for non-tail-recursive functions by using a trampoline. The example given in the API is straightforward: import scala.util.control.TailCalls._ def isEven(xs: List[Int]): TailRec[Boolean] = if (xs.isEmpty) done(true) else tailcall(isOdd(xs.tail)) def isOdd(xs: List[Int]): TailRec[Boolean] = if (xs.isEmpty) done(false) else tailcall(isEven(xs.tail)) isEven((1 to 100000).toList).result However, the more interesting case is if you want to do some operations after the recursve call. I got a "naive"

Here is the code: function repeat(operation, num) { return function() { if (num <= 0) return operation() return repeat(operation, --num) } } function trampoline(fn) { while(fn && typeof fn === 'function') { fn = fn() } } module.exports = function(operation, num) { trampoline(function() { return repeat(operation, num) }) } I have read that the trampoline is used to deal with overflow problem, so the function would not just keep call itself and the stack up. But how does this snippet function? Especially the trampoline function? What did it exactly do by while and how did it accomplish its goal?

During recent discussions at work, someone referred to a trampoline function. I have read the description at Wikipedia . It is enough to give a general idea of the functionality, but I would like something a bit more concrete. Do you have a simple snippet of code that would illustrate a trampoline? There is also the LISP sense of 'trampoline' as described on Wikipedia: Used in some LISP implementations, a trampoline is a loop that iteratively invokes thunk-returning functions. A single trampoline is sufficient to express all control transfers of a program; a program so expressed is trampolined