Tail-call optimization in C is relatively recent (2025)

Post by pjmlp » Mon, Aug 10, 2026, 6:37 PM UTC

tialaramex wrote: post #34

chriswarbo wrote: post #10

Earlier quoted context omitted.

Sounds similar to @tailrec in Scala I personally use the phrase "tail call elimination" when it's a requirement that can be relied on; and "tail call optimisation" when it might be implementation-dependent, context-dependent, limited (e.g. to immediate self-calls), etc.

I am definitely not a Scala expert. As I wrote in a sibling comment, the key benefit here is the extra work from the compiler to deliver what you wanted, on top of the diagnostic if it can't. I don't know if Scala has the problem that `become` addresses (C++ calls this RAII, but I have no idea what Scala would call it if they have the same idea) However in my brief attempt to validate what Scala does do here, I found…

Post by groundzeros2015 » Mon, Aug 10, 2026, 6:38 PM UTC

webstrand wrote: post #67

groundzeros2015 wrote: post #13

Earlier quoted context omitted.

Js really should have it. I think the shift in style from functional and manual prototype chains to Java classes is quite disappointing.

ES6 class syntax is still mostly just syntax sugar overtop prototypical inheritance. JS _does_ still have TCO (called Proper Tail Calls), Safari's JavaScriptCore implements it, and is technically the only conforming interpreter.

Post by layer8 » Mon, Aug 10, 2026, 6:39 PM UTC

mort96 wrote: post #56

kevincox wrote: post #39

Earlier quoted context omitted.

It's hard to argue that it isn't an optimization, because it doesn't affect the semantics of the program. However most optimizations are very hard to observe. The vast majority of optimizations only affect code size and runtime. TCO is one of the few exceptions. It affects memory usage, and more sensitive stack memory at that. This is why a missed optimization can be so much more catastrophic and it is worth consider…

If the semantics of 'while (true)' was "will crash the program after an implementation-defined but often fairly low number of iterations", I would stop using 'while (true)'.

Post by layer8 » Mon, Aug 10, 2026, 6:53 PM UTC

fluoridation wrote: post #65

adrian_b wrote: post #64

Earlier quoted context omitted.

Not every tail call is for a loop. You can have a set of mutually recursive functions, which tail call each other. In C you can write state machines using "goto" (the implementations with "switch" are typically much more inefficient), but in languages with guaranteed tail call optimizations you can write a state machine where each state is a function. In general, it is frequent enough to call another function as the…

I can't see why the calling convention could matter. Can you give an example?

Post by norir » Mon, Aug 10, 2026, 7:02 PM UTC

torginus wrote: post #57

What practical patterns are enabled by TCO in C? My impression is that every tail call can written as a loop much more naturally. Tail calls are important in functional languages where you don't have mutable loop variables. And imo they are an ugly hack even there - one of the few core constructs where its readily apparent you're not programming an abstract machine but a real, and limited computer. For example the mo…

    local factorial do
      local function impl(n, acc)
        if n == 1 then
          return acc
        else
          return impl(n - 1, acc * n)
        end
      end
      factorial = function(n)
        if n 

    local acc = 1
    repeat
      acc = acc * n
      n = n - 1
    until n == 1
    return acc