try {
    die "foobar\n";
    print "OK";
} catch {
    print "FAILED!\n";
};
[download]

try( sub { die "Foobar"; print "OK"; },
     catch(sub { print "FAILED!\n"; })
   );
[download]

The print statment in the catch subroutine definition at line #10 is confusing you (and probably everybody else).

The catch subroutine is only called once, and its only purpose is to return the sub ref passed to it, which is then passed as an argument to try in @_. An anonymous subroutine composer could be used in place of the call to catch for the same effect:

try {
    ...
} sub {
    print "FAILED!\n";
}
[download]

The subroutine reference passed to try in @_ is evaluated at line #4. The eval block catches the exception caused by the die statement in line #13 and sets $@ to the exception string, "foobar\n" (it's worth noting that if the argument to die includes a newline, line number information will not be included in the exception string).

Line #5 checks for an eval exception and if true, localizes $_ and sets it to the value of the eval exception, then calls the anonymous subroutine returned by catch, which just happens to be stored in a lexical variable named "$catch". Since the anonymous subroutine is called from the same scope as the localized $_, that copy of $_ is visible to the anonymous subroutine, not the global $_.

This is where you've missed the purpose of this code: the anonymous subroutine returned by catch should check the value in $_ for the specific exception set by the anonymous subroutine executed by eval, then take the appropriate action if the "tried" code failed.

Think of "try/catch" as "try something, and if it fails, recover gracefully (if possible)".

Now that you've read this and hopefully understand the code a little better, go back and read the example code in the perlsub manpage "Prototypes" section. It should make a lot more sense now.

 1     sub try (&@) {
 2         print "try();\n";
 3         my($try,$catch) = @_;
 4         eval { &$try };
 5         if ($@) {
 6             local $_ = $@;
 7             &$catch;
 8         }
 9     }
10     sub catch (&) { print "catch();\n"; $_[0] }
11     
12     try {
13         die "foobar\n";
14         print "OK";
15     
16     } catch {
17         print "FAILED!\n";
18     };
[download]

Lines 16-18 should probably be written:

16     } catch {
17         /^foobar$/ and print "FAILED!\n";
18     };
[download]

conv

converter your reply helped me understand this to every tiny detail, numerous thanks for your effort my fellow monk! ;-)

I didn't expect someone to put up so much effort and explain an answer to my question so thoroughly.

I feel a little dumb now though.. that I failed to understand the concept heh. Actually, it was my first try at subroutine prototypes.

Say, I figure the code could be rewritten as follows:

     try({die "foobar\n"; print "OK";12}, 
         catch {print "FAILED!\n";}
         );
[download]

*laugh* I guess my struggle for Java-like OO-ish exception handling hit back and confused me beyound disbelief. lol ;-)

cheers, vladb



"There is no system but GNU, and Linux is one of its kernels." -- Confession of Faith

sub1(sub2());

sub sub1 {
  my @array = @_;
  ...
}

sub sub2 {
  ...
  return @arr;
}
[download]

-- Brett

Go not to the Elves for counsel, for they will say both no and yes