[ruby-core:103507] [Ruby master Feature#12543] explicit tail call syntax: foo() then return

Issue #12543 has been updated by jwmittag (Jテカrg W Mittag).


mame (Yusuke Endoh) wrote in #note-9:
> And I have another concern.  If tail call optimization is on by default, some people will strongly depend on it.

That's the point. Proper Tail Calls allow you to write code that is otherwise *impossible* to write. But that is *crucially* dependent on the knowledge that the call will *always be optimized, no matter what*.

For example, you can very elegantly express State Machines in an Object-Oriented manner: every state is an object, every transition is a method call. But in doing this, you just move from state to state through the state machine, *you never return*. This very elegant Object-Oriented encoding of State Machines depends on Proper Tail Calls.

[Guy L. Steele has argued that Proper Tail Calls are *required* for Object-Orientation Languages](https://eighty-twenty.org/2011/10/01/oo-tail-calls).

One thing we should be very careful about is whether we are talking about *Language Semantics* (these are usually called *Proper Tail Calls* or *Properly-Implemented Tail Call Handling (PITCH)*) or a simple *Compiler Optimization* (these are typically *Tail Call Optimization*). The main difference is that Proper Tail Calls are a guarantee made by the language specification. These calls are guaranteed to be optimized, under any circumstances, in any implementation (YARV, TruffleRuby, JRuby, Opal, Artichoke, 窶ヲ). Whereas TCO may or may not be applied depending on the implementation, the version, the optimization level, the surrounding code, the phase of the moon, a command line option, or even a random coin flip.

Proper Tail Calls are *required* for certain kinds of modularity, they are required for certain kinds of designs. When I talk about Proper Tail Calls, that is what I mean: **IFF** a call meets the definition of a Tail Call (whatever definition the community settles on), then it is *guaranteed* to be optimized in *every Ruby implementation*, always.

Only this kind of guarantee will allow one to write code that depends on Proper Tail Calls.

----------------------------------------
Feature #12543: explicit tail call syntax: foo() then return
https://bugs.ruby-lang.org/issues/12543#change-91605

* Author: mame (Yusuke Endoh)
* Status: Assigned
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
How about introducing a new syntax for tail call?

```
def foo()
  foo()
end
foo() #=> stack level too deep
```

```
def bar()
  bar() then return
end
bar() #=> infinite loop
```

* no new keyword (cf. `goto foo()`)
* no conflict with any existing syntax
* an experimental patch is available (attached)
* no shift/reduce nor reduce/reduce conflict in parse.y

-- 
Yusuke Endoh <[e-mail]>

---Files--------------------------------
then_return.patch (9.18 KB)


-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>