Consider the following interaction with the REPL. First we define a class with a factorial method: scala> class C { def fact(n: Int, result: Int): Int = if(n == 0) result else fact(n – 1, n * result) } defined class C scala> (new C).fact(5, 1) res11: Int = 120 Now let’s override it in … Read more
The following is an implementation of tail recursion modulo cons optimization, resulting in a fully tail recursive code. It copies the input structure and then appends the new element to it, by mutation, in the top-down manner. Since this mutation is done to its internal freshly-created data, it is still functional on the outside (does … Read more
From the “Tail calls, @tailrec and trampolines” blog post: In Scala 2.8, you will also be able to use the new @tailrec annotation to get information about which methods are optimised. This annotation lets you mark specific methods that you hope the compiler will optimise. You will then get a warning if they are not … Read more
There are two fairly-distinct questions here: Does or doesn’t Node.js do TCO? How does this magical yield thing work in Node.js? Does or doesn’t Node.js do TCO? TL;DR: Not anymore, as of Node 8.x. It did for a while, behind one flag or another, but as of this writing (November 2017) it doesn’t anymore because … Read more
Diagnosing Java Code: Improving the Performance of Your Java Code (alt) explains why the JVM does not support tail-call optimization. But although it is well known how to automatically transform a tail-recursive function into a simple loop, the Java specification doesn’t require that this transformation be made. Presumably, one reason it is not a requirement … Read more
Haskell uses lazy-evaluation to implement recursion, so treats anything as a promise to provide a value when needed (this is called a thunk). Thunks get reduced only as much as necessary to proceed, no more. This resembles the way you simplify an expression mathematically, so it’s helpful to think of it that way. The fact … Read more
An example in JavaScript Here’s an example using JavaScript. Currently, most browsers do not support tail call optimisation and therefore the following snippet will fail const repeat = n => f => x => n === 0 ? x : repeat (n – 1) (f) (f(x)) console.log(repeat(1e3) (x => x + 1) (0)) // 1000 … Read more
Tail-call optimization is where you are able to avoid allocating a new stack frame for a function because the calling function will simply return the value that it gets from the called function. The most common use is tail-recursion, where a recursive function written to take advantage of tail-call optimization can use constant stack space. … Read more