Usually, when you want to return to the original call site, you want to simply perform a subroutine call:

#!perl
use strict;

my $counter = 0;
sub print_next_counter {
   print $counter++;
};

while ($counter < 20) {
    print_next_counter();
    print "----\n";
}
[download]

No, both programs do not work fine, as you would realize if you added 'use strict;' and 'use warnings;' to your programs.

Also 'retn' is just a bareword (in void context) and does nothing.

'goto' has no way to return, perhaps you are confusing it with the Basic command 'GOSUB' ?

goto $EXP

with $EXP = "label-name"

so

sub retn {
    goto $EXP
}
[download]

would do if you've set a global $EXP before.

Please note that you can't goto into a sub or a foreach loop, so returning there is not possible.

BUT in 99.9% of all cases there are far better solutions than that ...

... maybe you just need to try a continue block?

I'm not the expert on such things, and thought that everyone else already explained it well enough. But since you are still confused, I am giving it a go.

In your first example, goto-0.pl, I cannot imagine how you think it would work. What is the print sequence that you expect if the "goto-label / return-from-label" worked as you want it to?

In your second example, goto-1.pl, I believe you want to set a to 0, then skip over the "LOOP" and its two lines of commands, then run the while loop. In the while loop, you want to jump into the "LOOP" section, print and increment, then return to the while. If I have interpreted correctly, this would print

0----
1----
2----
...
17----
18----
19----
[download]

#!perl
use 5.012; # strict, //
use warnings;

my $a = 0;
while($a < 20) {
    mySubroutine();
    print "----\n";
}

sub mySubroutine {
    print $a++;
    # implied "return" from subroutine; you could make it explicit on 
+this line if you really wanted to
}

exit;
[download]

Actually, my guess is that both goto-0 and goto-1 were supposed to accomplish the same task. In which case my implementation works for either.

I cannot go to your mooo URL, because that domain is blocked my IT department, so I cannot see a more practical example of what you're trying to accomplish. But I am quite certain that nearly anything you claim you want to do with goto-labels and return-from-labels would be more practically implemented with subroutines. (There are a few "goto-like" constructs that would be better with nested loops, labels on loops, and judicious use of last LABEL, next LABEL, and redo LABEL) .... But since I cannot see your website (and I probably wouldn't have understood the examples there anyway, if your goto-0 is any indication the examples there), I cannot offer concrete implementations for other constructs if my working example doesn't do what you need.

I think if you really want more help finding an alternative to the non-existent goto/return pair, you will have to provide pseudocode showing the logic you think you need, using only prints and use goto and pseudoReturn in your pseudocode, and maybe one variable to show where you are in the flow or provide decision-making. Then show us the example output you desire from that pseudocode. Then we can, if we understand your example, show actual working perl code which will provide the same output, using either subroutines or nested while loops (or both). Or maybe give pseudocode with embedded line numbers, then list the sequence of line numbers that you think would run based on that pseudocode. But if you just direct us to an external website, then some of us (including me), will not be able to do anything more for you.

"[A] fool cannot be protected from his folly. If you attempt to do so, you will not only arouse his animosity but also you will be attempting to deprive him of whatever benefit he is capable of deriving from experience. Never attempt to teach a pig to sing; it wastes your time and annoys the pig." — RAH

The cake is a lie.
The cake is a lie.
The cake is a lie.

I think in such a stubborn case it's more efficient to just point him repeatedly to perlintro#Writing-subroutines

Writing subroutines

Writing subroutines is easy:

sub logger {
   my $logmessage = shift;
   open my $logfile, ">>", "my.log" or die "Could not open my.log: $!"
+;
   print $logfile $logmessage;
}
[download]

Now we can use the subroutine just as any other built-in function:

logger("We have a logger subroutine!");

What's that shift? Well, the arguments to a subroutine are available to us as a special array called @_ (see perlvar for more on that). The default argument to the shift function just happens to be @_. So my $logmessage = shift; shifts the first item off the list of arguments and assigns it to $logmessage.

We can manipulate @_ in other ways too:

my ($logmessage, $priority) = @_;       # common
my $logmessage = $_[0];                 # uncommon, and ugly
[download]

Subroutines can also return values:

sub square {
    my $num = shift;
    my $result = $num * $num;
    return $result;
}
[download]

Then use it like:

$sq = square(8);

For more information on writing subroutines, see perlsub

He should first tell us whats wrong with that.

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

There are practically no reasonable use cases for returning from a goto°, because in Perl one normally returns from a subroutine.

Please explain what's wrong with the solution you got demonstrated here:

• Re: how to return from a goto ?

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

°) while it's possible, it's so complicated and error prone, that it rarely pays off.

short answer: do not use goto, period.

long answer: if you have to ask how to use it, you should def not be using it!!!