Why can’t Java use the same approach ? I can’t say which approach will be used, but it’s better-explained in Project Loom’s proposal: As adding the ability to manipulate call stacks to the JVM will undoubtedly be required, it is also the goal of this project to add an even lighter-weight construct that will allow … Read more
C# compiler does not give you any guarantees about tail-call optimizations because C# programs usually use loops and so they do not rely on the tail-call optimizations. So, in C#, this is simply a JIT optimization that may or may not happen (and you cannot rely on it). F# compiler is designed to handle functional … Read more
Start with a simple task, like mapping items from ‘a to ‘b in a list. We want to write a function which has the signature val map: (‘a -> ‘b) -> ‘a list -> ‘b list Where map (fun x -> x * 2) [1;2;3;4;5] == [2;4;6;8;10] Start with non-tail recursive version: let rec map … Read more
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
Remember that Haskell is lazy. Your computation (l+1) will not occur until it’s absolutely necessary. The ‘easy’ fix is to use ‘$!’ to force evaluation: myLength :: [a] -> Integer myLength xs = len xs 0 where len [] l = l len (x:xs) l = len xs $! (l+1) main = print $ myLength … Read more
Scala can only optimise this if the last call is a call to the method itself. Well, the last call is not to allStrings, it’s actually to the :: (cons) method. A way to make this tail recursive is to add an accumulator parameter, for example: def allStrings(expr: => String, acc: List[String] = Nil): List[String] … Read more
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 … Read more
Shepmaster’s answer explains that tail call elimination is merely an optimization, not a guarantee, in Rust. But “never guaranteed” doesn’t mean “never happens”. Let’s take a look at what the compiler does with some real code. Does it happen in this function? As of right now, the latest release of Rust available on Compiler Explorer … Read more
Yes, actually you can take some code and convert every function call—and every return—into a tail call. What you end up with is called continuation-passing style, or CPS. For example, here’s a function containing two recursive calls: (define (count-tree t) (if (pair? t) (+ (count-tree (car t)) (count-tree (cdr t))) 1)) And here’s how it … Read more
Executive summary: I wrote a simple implementation of an algorithm… that wasn’t tail-recursive. I compiled it with OCaml under Linux. It worked fine, and finished in 0.14 seconds. It was then time to port to F#. I translated the code (direct translation) to F#. I compiled under Windows, and run it – I got a … Read more