Personally, I use almost every tool^* in the toolbox. Some more than others. I don't use goto often, but I do use it. For instance, in code like this:

    my $max_tries = 10;
GETSTORE:
    my $url = ask_url();
    my $status = getstore($url, $file); 
    goto GETSTORE if $status == 200 && !-s $file && --$max_tries > 0;
    ... do stuff ...
    return $status;
[download]

    my $max_tries = 10;
    my $status;
    {
        my $url = ask_url();
        $status = getstore($url, $file);
        redo if $status == 200 && !-s $file && --$max_tries > 0;
    }
    .. do stuff ..
    return $status
[download]

^*Tools I never use that I can think of right now: formats, 1-arg open, study, and /o.

I'd write that as (untested)

while ( uninteresting() ) {};

    :
    :

sub uninteresting
{                       # I assume $file and $max_tries are globals
  my $url    = ask_url();
  my $status = getstore($url, $file);
  return ( $status == 200 && !-s $file && --$max_tries > 0 ); 
}
[download]

Well, neither $file nor $max_tries are globals. During the live time of the program the routine is called hundreds of times, and for each new call, I've a new file name, and 10 new tries. Besides, isn't using global variables a sin as bad as a goto?

But more importantly, the reason I wrote the code with the goto is that I need the $status afterwards. And I need to know whether the download eventually succeeded or not. Now, you can achieve all that by having uninteresting returning a list of two things (the status code, and whether it succeeded or not), but the code gets more complex that way.

I prefer the simplicity of the goto solution.

You don't say why you find the goto version more attractive. I guess because of the separate declaration and initialization of $status. However:

my $status;

do {
    $status = getstore (ask_url (), $file);
} while $status == 200 && !-s $file && --$max_tries > 0;
[download]

makes it clear that there is a loop involved and what the conditions on the loop are. Having $status declared outside the loop makes it clear that $status is required after the loop has terminated.

---

Perl's payment curve coincides with its learning curve.

But that suggests the loop is "normal". It isn't. Repeating a piece of the code is the exception - it may be repeated once every couple of thousand of times. Normal program flow just goes top to bottom. Using a rare construct (goto) signifies that. Using a regular loop doesn't.

And I prefer not to have a separate declaration and initilization. But that only plays a part in the decision.

Right, but especially in Perl there are some cases where you can't get around goto, e.g. in AUTOLOAD!

Well, it's called goto, but that's a little misleading. In many ways the use (often found in the context of AUTOLOAD) that you allude to is more akin to a magical call to a subroutine than to the conventional use of goto suggested by the OP.

---

Perl's payment curve coincides with its learning curve.