Some years ago, i used the goto when i needed a throw method with a stack trace that starts where the method was called. I used Exception::Class exceptions, and the method looked something like this:

sub throw {
  my $self = shift;
  my %args = @_;

  @_ = ('Local::Exception',
         # ... more params taken from %args and from the object ...
       );
  goto &Exception::Class::Base::throw;
}
[download]

Yep that's a case of wrapping a function call which inspects the call chain.

😊👍🏼

I did similar things too but with carp routines or recently with a self made logger.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}

You said "coroutines", but I think you meant "tail call elimination"?

I meant Co-routines, I saw someone demoing them in Perl many years ago in tinita's German Perl Board.

Not very efficient tho.

And my LISP skills are restricted to dabbling with emacs.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}

Implementing co-routines (co-operative multitasking) requires

• The ability to create a context (call stack and execution pointer).
• The ability to swap the active context with another.
• The ability to free a context.

(Example of a C co-routine implementation achieved using makecontext, swapcontext, getcontext and setcontext.)

goto &foo does not help with any of that.

On the other hand, it can be used to eliminate tail calls, and tail call elimination is something LISP does.

The OP uses goto &sub for tail call elimination.