Catch Me If You Can: Sugary Exception Handling in Perl

EXCEPTION HANDLING IN PERL

catch me if you can
YAPC EU 2009 = ASH BERLIN ‹ %DEVEL DECLARE / SCOPE UPPER ‹
eASH BERLIN aASH BERLIN ½ MST < FLORIAN RAGWITZ / VINCENT PIT
£MARK FOWLER / THE O’REILLY CAMEL
Tuesday, 11 August 2009

Catch Me If You Can:
Sugary exception handling with TryCatch.pm

Ash Berlin
YAPC::EU 2009 – Lison

A.K.A The please don’t sue me Title


Perl Sucks!
(and what to do about it)

Image courtesy of Mark Fowler

YAPC::EU 2007 – Vienna


Perl Sucks?

• Of course it does, it’s software
• Installing Modules is hard
• Perl programs are just scripts
• Its Exception handling is hateful


eval {};
sucks


eval sucks

• Sucky syntax
• Easy to get (subtly) wrong.
• return doesn’t work as expected
• eval BLOCK vs eval EXPR
• $@ is global


“But Perl already has
exception handling”
Lots of Exception::* and Error::* modules


None of them Perfect

• Some are just an exception framework
• Good; doesn’t solve catching problem
• Catching errors shouldn’t be hard


I want the Moon on a Stick

Exceptions in JavaScript

try {
someCallThatDies();
}
catch (e if e instanceof Error) {}
catch (f if f.length < 10) {}
catch (g) { /* otherwise */ }


The same in Perl
eval {
some_call_that_dies();
};
if (blessed($@) && $@->isa(‘Error’)) {
my $e = $@;
}
elsif (len($@) < 10 ) {
my $f = $@;
}
elsif ($@) {
my $g = $@;
}


The same in Perl
Done properly
{
local $@;
eval {
};
if (my $_e = $@) {
if (blessed($_e) && $_e->isa(‘Error’)) {
my $e = $_e;
}
elsif (len($_e) < 10 ) {
my $f = $_e;
}
else {
my $g = $_e;
}
}
}


That’s a lot to
write every time
Not very DRY


Using Error.pm

use Error qw(:try);
try { some_call_that_dies(); }
catch Error with {
my $e = shift;
}

Looking good so far…


Using Error.pm
use Error qw(:try);
try { some_call_that_dies(); }
catch Error with {
my $e = shift;
}
otherwise {
my $f = shift;
if (length($f) < 10) {
}
else {
my $g = $f;
}
} Less good :(


Problems with Error.pm

• (Not to single it out as bad)
• Its Exception Object class
• AND try/catch implementations
• sub {} closures are slow
• Speed for error free path is important


TryCatch.pm
use TryCatch;
try {
}
catch (Error $e) {}
catch ($f where {length < 10}) {}
catch ($g) {} # otherwise


TryCatch syntax

• try must be followed by a block
• Followed by zero or more catch clauses
• catch may be followed by a signature
• catch must also be followed by a block


Try syntax

• try keyword
• Followed by a block
• That was easy :)


Catch syntax

• catch keyword
• Followed by an optional signature:
(MyError $e where { } )

• Followed by a block.


Catch Sig syntax
• MyError is any valid Moose type constraint

• Optional
• Uses MooseX::Types for preference
• Else falls back to Moose’s string parsing
• Never quoted, always bare
• Example:
Str|ArrayRef[MyError]


Catch Sig syntax

• $e is the variable name for the error
• Will be created as “my $e” in the block
• A variable name is required


Catch Sig syntax

• Constraint (not type constraint)
• $_ is the error being tested.
• Much like grep or map, return truthy value
• PPI used to just get ‘everything in {}’


Syntax Notes

• try can be nested as deep as you like
• You can use return to exit the sub.
• No finally.Yet. It’s on my TODO


TryCatch example
sub foo {
try {
die MyError->new($_[0])
if $_[1] eq “class”;
die $_[0]
if $_[1] eq “plain”;

return “value”;
}
catch (MyError $e) { }
catch ($e where { /No Cheese!/ }) { }
catch ($e) { } # otherwise
}


TryCatch example
sub foo { This will return a value from
try { foo, not just the try/eval
die MyError->new($_[0])
if $_[1] eq “class”; i.e. use return natually
die $_[0]

return “value”;
}
}


TryCatch example
sub foo { Moose type constraints
try { handle the “is this a blessed
die MyError->new($_[0]) object” and similar checks
die $_[0]

return “value”;
}
}


TryCatch example
sub foo { If this wasn’t here, and the
try { plain error was thrown, it
die MyError->new($_[0]) would get re-thrown.
die $_[0]

return “value”;
}
}


xkcd.com

Implementation
Here Be (anthropomorphic) Dragons

Source Filters

• Have to look through the entire source
• And only change the bits they want.
• Perl is notoriously hard to parse
• Can cause odd bugs:


Source Filters
package ShootMeInTheHead;
use Moose;
use Switch;

sub foo {
my ($variable) = @_;
return $variable + 1;
}
sub bar {
return $variab1e + 1;
Global symbol "$variab1e" requires
} explicit package name at line 18.
}


Source Filters
use Moose;
use Switch;

# load switch statement

sub foo {
}
sub bar {
}


Devel::Declare

• Lets you change the source Perl is about to
compile
• Like a source ﬁlter
• But far less fragile.
• Key-hole source ﬁlter effect.


Using Devel::Declare
• When perl parses
catch ($e) { my $foo = …

• Sees catch as a OP_CONST



• Calls PL_check[OP_CONST]



• Devel::Declare hooks this
• And calls back into perl code



• Devel::Declare lets us change this into…
catch; { if (my $e = $@) { my $foo = …



• TryCatch doesn’t quite produce that code
• But it shows how things work
• Also uses B::Hooks::OP::{Check,PPaddr} to
solve the return problem


The return problem

• Simple:
sub foo { eval { return $val }; 1}

• Would be nice if it returned from foo
• vincent++ # Scope::Upper
• unwind HERE, @values;


The return problem

• Typing return would be better than unwind
• Install an extra PL_check hook on
OP_RETURN

• And install a custom op handler
• Makes return inside try behave like unwind


In short, lots of scary
XS.

use TryCatch;

try {
}
catch (Error $e) {}
catch ($f where {length < 10}) {}
catch ($g) {} # otherwise


use TryCatch;

try ;{
local $@;
eval {
};
$TryCatch::Error = $@;
}
if ($TryCatch::Error) {
if (TryCatch->check_tc('Error')){
my $e = $TryCatch::Error;
}
elsif (do {local $_ = $TryCatch::Error; length($_) < 10 }) {
my $f = $TryCatch::Error;
}
elsif (1){
my $g = $TryCatch::Error;
} # otherwise
else {
$@ = $TryCatch::Error; die
}
}


hu∙bris
noun
excessive pride or self-conﬁdence.
• (in Greek tragedy) excessive pride toward or deﬁance of the gods,
leading to nemesis.

DERIVATIVES
hu∙bris∙tic adjective

ORIGIN Greek.

Ash Berlin
<ash@cpan.org>

Questions?

Catch Me If You Can: Sugary Exception Handling in Perl

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (6)

Recently uploaded

Recently uploaded (20)

Catch Me If You Can: Sugary Exception Handling in Perl