That's what exceptions where made for, after all ;-)

Error handling is typically done either via return values (e.g. empty return - gives undef in scalar context or empty list in list context) or by exceptions (with raw eval/die or with a module which provides some syntactic sugar, such as Exception::Class).

There are also bizarre various ways to do this in perl, like the subroutine goto above, or you could stick a loop around the whole thing and call next in the subroutine instead of return. But imho these sorts of things don't aid readability or maintainability - which is the purpose of refactoring in the first place.

By convention, perl uses an undefined return as you have to signal an error. You need to test that return value to make the convention effective. partial_success() if not defined do_stuff();

It seems that your end logic makes the return value irrelevant. Setting $ERRNO or $! is always useful, since even the shell on end will honor and report that value.

begin();
goto &do_stuff;
end();

sub do_stuff {
    stuff();
    if (something went wrong) { return }
    more_stuff();
}
[download]

I don't think "never call end" is the desired effect.

begin();
do_stuff();
end();

sub do_stuff {
    my status = stuff();
    if (status is ok) { more_stuff(); }
    return status;
}
[download]

begin();
do_stuff();
end();

sub do_stuff {
    return stuff() and more_stuff();
}
[download]

Thank you all for the replies.

you could stick a loop around the whole thing and call next in the subroutine instead of return

I tried exactly that but it didn't work, complaining that it couldn't find the label.

LABEL: {
sub outer {
    inner();
}
sub inner {
    next LABEL;
}
}
[download]

C:\@Work\Perl>perl -wMstrict -e "LABEL: { outer(); }
sub outer {
  print qq(in outer() before inner() \n);
  inner();
  print qq(in outer() after inner() \n);
  }
sub inner {
  print qq(in inner() \n);
  no warnings;
  next;
  }"
in outer() before inner()
in inner()

C:\@Work\Perl>perl -wMstrict -e "LABEL: { outer(); }
sub outer {
  print qq(in outer() before inner() \n);
  inner();
  print qq(in outer() after inner() \n);
  }
sub inner {
  print qq(in inner() \n);
  no warnings;
  ;
  }"
in outer() before inner()
in inner()
in outer() after inner()
[download]

OK I went the seemingly cleanest route of exceptions. Now what has been one line of calling a function, became this bloat:

undef $@;
my @val = eval { do_stuff() };
if ($@) {
    if (ref $@ and $@->isa('SoftError')) {
        warn ${$@};    # SoftError object is a scalar ref with the mes
+sage
        return
    }
    else {
        die $@    # as if we had never caught it
    }
}
push @rv, @val;
[download]

What do you think?