explicit tail call syntax

[thejoshwolfe]

Progress

---

Proposal:

return @tailCall(foo, a, b, c);
// roughly equivalent to:
return foo(a, b, c);

The purpose of @tailCall() is to ensure that a tail call happens. If it cannot, the @tailCall() produces a compile error.

Here are some cases where a tail call is impossible:

• if the @tailCall() expression is not the operand of a return operator. e.g. return @tailCall(foo) - 1.
• if there are defer statements that would run after the @tailCall(). e.g. {defer bar(); return @tailCall(foo);}.
• if there is an implicit cast to convert the return value of the called function into the return value of the calling function. e.g. foo returns u8 and the caller returns ?u8.

See also #157.

[jfo]

This reminds me of clojure's recur keyword.

I am curious about how the compiler currently handles tail calls in code like:

fn r(x:u8) -> u8 {
    if (x < 10) {
        return r(x + 1);
    } else {
        return x;
    }
}

This is afaict never going to need any more than one stack frame. Would it currently use more than one? Is it possible / desirable to have the compiler identify tail call optimizable functions implicitly and what would / does that look like on the backend? Is the @tailCall built-in simply an assertion tool to verify that or would it be required to call it to perform the optimization? I would like for TCO to exist and I would similarly like to have a way to ask the compiler to verify that it is occurring, so I am 👍 in general, I'm just curious (and generally uninformed, currently) about how the specifics would look.

[ruffianeo]

I am not sure about the proposed syntax. Instead of it having function wrapper syntax (complex), a simple return tailcall foo(a,b,c) keyword would do. Working in the same spirit as the C ´´register`` keyword. It communicates intent and the compiler can deliver the news, if its not as the programmer hopes.

In order to make use of tail calls, as in the fold use case (which can be implemented as tail calls in other languages), thought should be spent on how a dynamically growing accumulator would work. filter predicate values = fold (\ acc value -> if predicate value then (value:acc) else acc) [] values. Sorry for the Haskell syntax.. I just found Zig today...

[andrewrk]

This is actually implemented already in the form of @call. However this issue is still open because the detection of when to emit a compile error is not implemented yet. I do not plan to add any additional syntax or builtins.