I think you are really creating a label named return here, followed by a constant expression. As that expression is the last expression evaluated, it is used as return value.

Look at this code: It returns 5 and gives a "Useless use of a constant in void context" warning:

sub foo
{
        return: 3;
        return 5;
}
[download]

Alexander

"Useless use of a constant in a void context"

Sorry, that's an artefact of my test code, actually what he was doing is more like:

sub cmd {
    my ($cmd) = @_;
    $cmd =~ s/\//\\/ig;
    my $ret = system($cmd);
  return: $ret;
}
[download]

which is horrible for other reasons, but it doesn't produce the above warning. It was only thanks to perltidy that I noticed that there was something funny going on on the last line.


- Boldra

but it doesn't produce the above warning

That is because in your code, it's the last statement in the sub. So by default, it's the value that is returned, even without a real return.

The construct is interpreted as a label, as the following code shows:

sub fn { 
    return: 3;
    print 'code after return?'
};

fn()
[download]

As the return value of a function is the last expression evaluated, the value of your constant block, 3, is returned.

Does the label get evaluated at all?

Given that 'return' does little other than declare the end of the subroutine, is there really anything wrong with his usage?

sub fn {
    if (1) {
        return: 3
    }
    2
}
[download]

Thanks for the explanation. If I understand correctly, by default the result of evaluating the last statement is returned when no explicit return is provided, and since declaring a label is not a statement, it doesn't get evaluated. I had expected something more like the behaviour from this:

sub fn {
  sub { 3 }
}
[download]

Where it's not the 3 that gets returned, rather it's a coderef to an anonymous subroutine.

As for 'wrong', you've guessed my meaning well. If the code is likely to mislead someone making changes at some point in the future, it is 'wrong' now. Since the 'return:' label doesn't cause the subroutine to return, putting code after it could have unexpected side-effects for anyone mistaking it for a normal 'return'.

BTW, is 'return 3;' a statement? If so, is it then a special exception to the rule 'blocks return the value of the last statement executed', or is the value of 'return 3' equal to 3 ?


- Boldra

I had expected something more like the behaviour from this:

sub fn {
  sub { 3 }
}
[download]

Where it's not the 3 that gets returned, rather it's a coderef to an anonymous subroutine.

Are you suggesting you didn't even try to run:

sub fn {
    return: 3
}
[download]

and see what it returns? Printing the return value of fn would have instantly revealed fn had returned '3', and not a code reference.

BTW, is 'return 3;' a statement?

Most certainly. What else could it be? It's not some pretty decorations.

If so, is it then a special exception to the rule 'blocks return the value of the last statement executed'

It's a statement. But it's not a block.

is the value of 'return 3' equal to 3 ?

sub foo {return 3;}
print foo();
__END__
3
[download]

So, what do you think?

BTW, is 'return 3;' a statement? If so, is it then a special exception to the rule 'blocks return the value of the last statement executed', or is the value of 'return 3' equal to 3 ?

No exception. That's indeed what a block returns, and the same goes for subs. They return the the value of the last statement executed.

sub foo {
   if (0) {       # <- Last statement executed
      1
   }
}                 # Foo returned 0.
[download]

sub foo {
   if (2) {
      3           # <- Last statement executed
   }
}                 # Foo returned 3.
[download]

sub foo {
   return 4;      # <- Last statement executed
   5
}                 # Foo returned 4.
[download]

It's effectively the same as:

print sub{ fred: 3 }->();;
3
[download]

The 'return:' is just a label that is never used; and the return is implicit.