return returns from the try block, not from the parent sub (note that this is also how eval works, but not how TryCatch works):

I would return a value from the try block that signals error or no error, and put the subs return() outside of the try block

sub foo {
   my $error = 0;
   try {
      die;
   }
   catch {
      print "error\n";
      $error = 1;
   }
   return if $error;
   print "no_err\n";
}
[download]

I agree from a program flow point-of-view, it would be better if the return inside the catch worked as expected - it may be that the "catch" is itself similar to a sub, and the return is returning from that?

um, it says what try returns, what catch returns ... see this example

  try {
    die_sometimes();
  } catch {
    # ...code run in case of error
  } finally {
    if (@_) {
      print "The try block died with: @_\n";
    } else {
      print "The try block ran without error.\n";
    }
  };
[download]

if you want to return from your sub from within a try/catch then use as directed

 use TryCatch;

 sub foo {
   my ($self) = @_;

   try {
     die Some::Class->new(code => 404 ) if $self->not_found;
     return "return value from foo";
   }
   catch (Some::Class $e where { $_->code > 100 } ) {
   }
 }
[download]

Try::Tiny is for when TryCatch is too much, it is not a drop in replacement, mind the caveats

um, not in the CPAN documentation:

This module provides bare bones try/catch/finally statements that are designed to minimize common mistakes with eval blocks, and NOTHING else. This is unlike TryCatch which provides a nice syntax and avoids adding another call stack layer, and supports calling return from the try block to return from the parent subroutine.

   try {
      die;
   }
   catch {
      print 'error';
      return;        # Not very useful!
   };
[download]

   &try(
      sub {
         die;
      }, 
      &catch(
         sub {
            print 'error';
            return;        # Not very useful!
         },
      ),
   );
[download]

Placing a return in the the sub you're passing to try or the sub you're passing to catch will only exit that sub (if and when it's called).

Zephram is doing awesome work with the Perl parser which will provide clean means of providing modules like Try::Tiny without this issue.

There currently exists such a module, but it uses some trickier means of doing this.