tail-call-optimization

Steve Yegge mentioned it in a blog post and I have no idea what it means, could someone fill me in? Is it the same thing as tail call optimization ? Tail call elimination is an optimization that saves stack space. It replaces a function call with a goto . Tail recursion elimination is the same thing, but with the added constraint that the function is calling itself. Basically, if the very last thing a function A does is return A(params...) then you can eliminate the allocation of a stack frame and instead set the appropriate registers and jump directly into the body of the function. Consider

Where do JVM Implementations differ (except licensing)? Does every JVM implement Type Erasure for the Generic handling? Where are the differences between: JRockit IBM JVM SUN JVM Open JDK Blackdown Kaffe ..... Deals one of them with Tail-Call-Optimization? James Schek JVM implementations can differ in the way they implement JIT compiling, optimizations, garbage collection, platforms supported, version of Java supported, etc. They all must meet set of features and behaviors so that it will execute your Java bytecodes correctly. As you've pointed out, the major difference tends to be in

Does the Go programming language, as of now, optimize tail calls ? If not, does it at least optimize tail-recursive calls of a function to itself? Rostyslav Dzinko Everything you can find over the Internet, that "Go supports tailable recursions in some cases", and that was told in mailing list : It is already there in 6g/8g for certain cases, and in gccgo somewhat more generally. We do not currently plan to change the language to require that compilers implement tail call optimization in all cases. If you must have a tail call, you use a loop or a goto statement. To get those cases you'd

While formulating an answer to another SO question , I came across some strange behaviour regarding tail recursion in Mathematica. The Mathematica documentation hints that tail call optimization might be performed. But my own experiments give conflicting results. Contrast, for example, the following two expressions. The first crashes the 7.0.1 kernel, presumably due to stack exhaustion: (* warning: crashes the kernel! *) Module[{f, n = 0}, f[x_] := (n += 1; f[x + 1]); TimeConstrained[Block[{$RecursionLimit = Infinity}, f[0]], 300, n] ] The second runs to completion, appearing to exploit tail

In particular if I have the following code: func sum(n: Int, acc: Int) -> Int { if n == 0 { return acc } else { return sum(n - 1, acc + n) } } Will Swift compiler optimize it to a loop? And does it so in a more interesting case below? func isOdd(n: Int) -> Bool { if n == 0 { return false; } else { return isEven(n - 1) } } func isEven(n: Int) -> Bool { if n == 0 { return true } else { return isOdd(n - 1) } } The best way to check is to examine the assembly language code generated by the compiler. I took the code above and compiled it with: swift -O3 -S tco.swift >tco.asm The relevant part of

i see several examples of implementing append an element to a list, but all are not using tail recursion . how to implement such a function in a functional style? (define (append-list lst elem) expr) 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 not alter any data passed into it and has no observable