Some languages (like Eiffel) disallow such a construct to make it easier to prove the correctness, and to get a better idea about the flow of the program (which is in this case: it runs through the method until it hits the end of that method).

But I found return and last useful at times, and wouldn't want to miss it.

For this to _really_ be nice, stuff like if would have to return the last value of the executed block:

sub is_even { if (shift % 2) { 0 } else { 1 } }
[download]

We already have the ternary operator, but I find it can get hard to maintain when used often in one statement. Sparkling some do { .. }'s in only makes it a bit better.

---

Ordinary morality is for ordinary people. -- Aleister Crowley

sub foo {
   for (...) {
      return 1 if ...;
   }
   return 0;
}
[download]

sub foo {
   my $found = 0;
   for (...) {
      if (...) {
         $found = 1;
         last;
      }
   }
   return $found;
}
[download]

Also compare the relatively simple

sub direct_return {
  my ($enum,$check_type,$enums) = @_;
  foreach my $enum (@$enums) {
    return 1 if ( $check_type eq $enum);
  }
  return;
}
[download]

sub otherwise {
  my ($enum,$check_type,$enums) = @_;
  my $flag = 0;
 LOOP:
  foreach my $enum (@$enums) {
    if ( $check_type eq $enum) {
      $flag = 1;
      last LOOP;  # not really needed unless you've got nested loops
    }
  }
  return $flag ? $flag : wantarray ? () : undef;
}
[download]

Not to "pile on", but I wanted to note that over the years I've found "early return" to be one of the best refactoring tools. I've used it to turn many a convoluted loops with overly complex flow control into a "trivial" / "obvious" loop that calls a very simple subroutine with an early return. It is the most maintainable of "jump out here" flows, quite a bit better than last or my $done= 0; and tons better than "bare block as 'loop' with redo" [expletive], for example.

The other way to write this and to keep efficiency is something like:

my($flag)=0;
foreach my $enum( @$enums)
{
    if ( $check_type eq $enum) {
        $flag = 1;
        last;
    }
}
return $flag;
[download]

-Scott

Update: I like anonymous monk's one line grep version above even more :-)

I don't think there is anything actually bad in exiting from within a loop but...

...I too don't like it :)

I think of it as inelegant. My personal feeling is that a sub should end at or near the end of its block, but again perhaps I'm just beeing fussy.

return 1  if grep { $check_type eq $_ } @$enums;
[download]

Very short but not very efficient because the implicit loop is not aborted at the first successful match. Because grep is returning the number of successful matches in scalar context all list elements are getting checked.
More efficient would be:

use List::MoreUtils;

return 1  if any { $check_type eq $_ } @$enums;
[download]

meh. Figure of speech :) Cheers WeeDom

Early exits in various guises are a powerful tool in making program flow clear and maintainable. They are very good tools for avoiding levels of nesting and thus the obfuscation of program flow and context that levels of nesting engender.

A related style issue to consider is instead of:

for ... {
    if ... {
       ...
    } else {
       ...
    }
}
[download]

use

for ... {
    if ... {
       ...
       next;
    }

    ...
}
[download]

especially where the true path is a trivial case, or can be made into a trivial (small number of lines of code) case such as an empty line to be skipped or an error condition.

In other words, deal with the trivia and fluff first and early exit where possible to avoid levels of indentation.

It sucked then, and it still sucks now. return inside a loop is perfectly acceptable.

--
¹Anyone else remember Jackson Structured Programming?

Oh, do I remember! With the same relish as I remember being beaned in the head with a chalkboard eraser by my teacher for talking in class in 3rd Grade or of being paddled in the principal's office for getting into a fight on the playground in 4th Grade. Yeh, I remember.

ack Albuquerque, NM

I think a spanking is in order.