I confess I like Common Lisp's TAGBODY far more than I feel like I should. Having constrained GOTO semantics to a short section of the codebase is surprisingly useful.

▲

adrian_b 4 hours ago | parent | next [-]

Following the recommendations of Knuth, the language Mesa, which was implemented at Xerox during the seventies, and which was a source of inspiration for various later languages, including Modula, Ada and Python, included a form of "restricted GOTO" which is the most useful kind of GOTO in my opinion.

The Mesa restricted GOTO allowed jumping forwards, but not backwards, and it allowed jumping towards an outer block, but not towards an inner block.

These 2 restrictions eliminate all the "harmful" features of the traditional GOTO, while retaining its advantages for handling exceptional conditions or for terminating multiple levels of nested program structures.

The Common Lisp TAGBODY appears to be only partially restricted, by allowing backward jumps, so it does not prevent the kind of hard-to-understand program structures for which GOTO was criticized.

GOTOs in random directions may be used to implement state machines, but such state machines can still be implemented in a language with restricted GOTO by not using GOTO, but by using mutually recursive procedures, if tail-call optimization is guaranteed.

	▲	taeric 3 hours ago \| parent [-]
		I'm not clear that jumping backwards is that tough to reason with. Notably, Knuth's algorithms do that quite commonly, right? I do think they need to be somewhat constrained to not jump to places that need new things initialized. Which, it is truly mind blowing to know folks used to just jump straight into other functions. Mid function. Because why not.

▲

pmcgoron 5 hours ago | parent | prev | next [-]

From John Cowan:

TAGBODY doesn't actually require continuations, delimited or undelimited, just proper tail calling. A macro can rewrite each section of the TAGBODY into a procedure nested within a `let` that tail-calls its successor, and the body of the `let` tail-calls the first procedure. (GO tag) is then equivalent to just (tag). This is a great way of doing state machines. Chicken has a tagbody egg, I think.

▲

kccqzy 7 hours ago | parent | prev | next [-]

Constrained GOTO semantics sounds a lot like delimited continuations. Indeed I think Scheme continuations are a little too powerful for regular use by having the possibility of global effect (like longjmp). Delimited continuations make the effect more local.

▲

taeric 6 hours ago | parent | next [-]

Delimited continuations always bounced off of me. In theory, they should be a lot like coroutines? I think, in practice, I just never really internalized all that goes into managing the current "environment" for a piece of code that is managed by the call state.

Like, I have a few partial mental models for everything that they pull together. I haven't really tried to build on that, though. Should put some time to that.

▲

mikkupikku 6 hours ago | parent [-]

You could implement coroutines with deliminated continuations, which is probably the best way to use deliminated continuations.

	▲	jasonhemann 22 minutes ago \| parent [-]
		Effect handlers would like to have a word.

▲

richdougherty 6 hours ago | parent | prev [-]

If you'll excuse the self-post, here's a blog post on goto with delimited continuations.

https://rd.nz/2009/03/goto-in-scala.html

It uses an experimental compiler plugin for the Scala compiler. It's typesafe at compile time. At runtime unfortunately it relies on exceptions for control flow.

▲

Joker_vD 5 hours ago | parent | prev | next [-]

Do you use it mostly as "labeled breaks" or to throw the values out of closures?

	▲	taeric 5 hours ago \| parent [-]
		I haven't used it much at all, to be clear. I just found it surprisingly fun the last few times I played with it. The specific thing it made a lot easier was implementing algorithms the way that Knuth writes them down. Which is very much a set of steps with specific calls on what step to go to next. I think the reason I found it fun to play with was that I found that style of laying out what needed to be done was easier to work with than the standard breakdown that making everything a function or an object seems to require. For me, it was a lot easier. Edit: I have one of the times I used this here: https://taeric.github.io/many_sums.html I did not put any effort into cleaning up that code, though. So it can probably work as an argument in either direction. :D

▲

4 hours ago | parent | prev [-]

[deleted]