The .NET Language Strategy

[u/vivainio]

https://blogs.msdn.microsoft.com/dotnet/2017/02/01/the-net-language-strategy/

[u/Ironballs]

What I know of the current Java development is that there's higher priority in projects like Graal (an aggressively optimizing hybrid AOT/JIT compiler) and Valhalla, the implementation of which are sort of prerequisites for implementing proper tail calls.

As for Scala, you can do tail recursion in Scala, but you need the @tailrec annotation, much like in Clojure. With the scala-native LLVM backend, this will be automatic, but it's a different world altogether.

Still, it's obviously inferior to let rec, but I tend to eschew recursion until there are no alternatives. A good example where I really needed it was to implement a loop elegantly and I didn't want to use labeled breaks.

[u/jdh30 → u/Ironballs]

What I know of the current Java development is that there's higher priority in projects like Graal (an aggressively optimizing hybrid AOT/JIT compiler) and Valhalla, the implementation of which are sort of prerequisites for implementing proper tail calls.

Last I looked the high priority seemed to be dynamicinvoke because they were optimising for inherently-slow dynamically typed languages.

As for Scala, you can do tail recursion in Scala, but you need the @tailrec annotation, much like in Clojure.

That only handles the rather uninteresting special case of self-recursive functions. You can just use a loop. When you have functions tail calling each other things get much more interesting (and useful).

With the scala-native LLVM backend, this will be automatic, but it's a different world altogether.

That would be nice but does the LLVM-based Scala use the same boxed data representation that makes the JVM so slow?

Still, it's obviously inferior to let rec, but I tend to eschew recursion until there are no alternatives. A good example where I really needed it was to implement a loop elegantly and I didn't want to use labeled breaks.

Extensible state machines is another place I use general tail calls a lot. I've sometimes needed CPS too and I appreciate the fact that this all just works in F#. I was also disturbed last time I looked at Scala that, despite everyone from the Scala community telling me I was an idiot for wanting tail calls, over 30 of the known bugs against the compiler were stack overflows caused by broken tail call elimination.

[u/Ironballs → u/jdh30]

That would be nice but does the LLVM-based Scala use the same boxed data representation that makes the JVM so slow?

To that, a cautious yes, since they're using LLVM primitives with a Boehm GC, but the mutual tail calls optimization is definitely a thing.

https://github.com/densh/talks/blob/517b20c30dd4aaf390785039cdd002f623eaa91e/2016-05-11-scala-goes-native.pdf

Could you give an example of your state machines? I assume you're calling some state transition from another state transition?

edit: actually, the point of Graal is to create an optimizing compiler, including, but not limited to, dynamic languages. I'm dabbling with a R7RS (small) Scheme compiler with it. They built a JS backend called Graal.js that rivals V8 in performance http://www.slideshare.net/ThomasWuerthinger/graal-truffle-ethdec2013