tail-call-optimization

What is the current state of Tail Call Optimization (TCO) implementation on Mono (2.11) ? Read somewhere that all the codebase would need to be modified to use a callee-pops-arguments convention. What is the status of this change ? Is the ARM/Linux port up to date on this matter ? Thanks! Tail calls definitely work on mono on linux - tested using let rec f a = f (a+1) which didn't crash - tested on Mono 2.10.2 UPDATE Tested with link from Brian - https://bugzilla.novell.com/show_bug.cgi?id=476785 which crashes on Mono 2.10.2 despite generating .tail instructions 来源： https://stackoverflow.com

Consider the following code: int fac_aux( int x, int res ) { if( x == 1 ) return res; else return fac_aux( x - 1, res * x ); } int fac( int x ) { return fac_aux( x, 1 ); } int main() { int x = fac( 50 ); std::cout << x; return 0; } According to generated asm file everything is ok, tail call is optimized. Try to replace int x = fac( 50 ); with int x = fac_aux( 50, 1 ); Strange enough, but tail call optimization is disappeared. As far as I remember there was no such a strange compiler behaviour in VS2008. Any ideas why these things happen and how to be sure of tail call optimization is done? ;

I coded 3 factorial algorithms: First, I expect to fail by Stack Overflow. No problem. Second, I try tail recusive call , convert previous algorithm from recursive to iterative. It doesn't work but I don't understand why . Third, I use trampoline() method and works fine as I expect. def factorial factorial = { BigInteger n -> if (n == 1) return 1 n * factorial(n - 1) } factorial(1000) // Stack Overflow factorial = { Integer n, BigInteger acc = 1 -> if (n == 1) return acc factorial(n - 1, n * acc) } factorial(1000) // Stack Overflow, why??? factorial = { Integer n, BigInteger acc = 1 -> if (n =

I just started Haskell 2 days ago so I'm not yet sure about how to optimise my code. As an exercise, I have rewritten foldl and foldr ( I will give foldl here but foldr is the same, replacing last with head and init with tail ). The code is: module Main where myFoldl :: ( a -> ( b -> a ) ) -> a -> ( [b] -> a ) myFoldl func = ( \x -> (\theList -> if (length theList == 0) then x else myFoldl func (func x (last theList) ) (init theList) ) ) My only concern is that I suspect Haskell can't apply tail call optimisation here because the recursive call is not made at the end of the function. How can I

So apparently, there's been a big brouhaha over whether or not Python needs tail call optimization. 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, could someone give me a snippet of code that would be greatly simplified using TCO? Personally, i put great value on tail call optimization; but mainly because it makes recursion as efficient as iteration (or makes iteration

Since .net has the TailCall opcode, can this be used to deterime if an F# function is truly tail recursive? If it is true, has anyone made a VS add-in that identifies tail and non-tail functions? See this blog post on the F# team blog for a summary of how F# compiles tail calls. In short, Direct recursive tail calls are typically converted into loops. Mutual recursion and indirect non-recursive tail calls are typically turned into .NET tail calls. but see the full post for all of the gory details. Yes, if the compiler emits the tail call instruction, that call will be tail recursive (as of CLR

Possible Duplicate: Why does the JVM still not support tail-call optimization? I see so many different answers online, so I thought I'd ask the experts. There is difference between tail recursion and tail recursion optimization. Tail recursion is supported by java because there is nothing special in it, tail recursion optimization is not supported. 来源： https://stackoverflow.com/questions/4401052/does-java-support-tail-recursion