Re: eval to replace die? (Exceptions and Error Handling References)

I doubt that PBP (2005) is up to date with the latest developments in this area. The recently released (2010) 2nd edition of Effective Perl Programming by brian_d_foy recommends the CPAN Try::Tiny module (released 2009) and the new core autodie pragma (added to perl 5.10.1 in 2009): see items 101 ("Use die to generate exceptions") and 103 ("Handle exceptions properly"). In particular, item 103 summarizes with "handling $@ is tricky, but Try::Tiny does it correctly". Note that Try::Tiny has zero dependencies.

2015 update: The excellent Modern Perl book by chromatic also recommends Try::Tiny; from its "Style and Efficacy" chapter, "Exception Caveats" sub-section:

Using $@ correctly requires you to navigate several subtle risks:

Unlocalized uses further down the dynamic scope may modify $@
It may contain an object which overrides its boolean value to return false
A signal handler (especially the DIE signal handler) may change $@
The destruction of an object during scope exit may call eval and change $@

use feature 'try' (2023 update: for perl 5.38+)

As clarified with a complete perl v5.38 example program, note that perl v5.34 added try/catch syntax, inspired by Syntax::Keyword::Try:

use feature 'try';
try {
   do_a_thing();
}
catch ( $e ) {
   warn "It failed - $e";
}
[download]

perl v5.36 added finally blocks to try/catch, also inspired by Syntax::Keyword::Try:

use feature 'try';
try {
   do_a_thing();
}
catch( $e ) { ... }
finally {
   cleanup();
}
[download]

Note that try-catch feature is no longer experimental with perl v5.40 - its use without a finally block no longer prints a warning but it still must be enabled with the 'try' feature. The optional finally block is still considered experimental and emits a warning, except when explicitly disabled with no warnings "experimental::try";.

Some perldoc References

die - is how you throw exceptions in Perl
eval - used to execute a little Perl program, trapping any errors encountered so they don't crash the calling program
Carp - alternative warn and die for modules
autodie - Replace functions with ones that succeed or die with lexical scope
Fatal - Replace functions with equivalents which succeed or die

Try Catch Exception Handling
defer blocks
experimental - Experimental features made easy
feature - Perl pragma to enable new features

Exception Safety and RAII

RAII (Resource Acquisition is Initialization) is very useful when throwing exceptions in Perl (via die).

To give a very simple example, this code:

use strict;
use warnings;
sub fred {
    my $fname = 'f.tmp';
    open( FH, '<', $fname ) or die "error: open '$fname': $!";
    print "file '$fname' opened ok\n";
    # ... process file here
    die "oops";   # if something went wrong
    close(FH);
}
my $ok = eval { fred(); 1 };    # see [id://11130946]
if (!$ok) { print "died: $@\n" }
# oops, handle FH is still open if an exception was thrown.
my $line = <FH>;
print "oops, FH is still open:$line\n";
[download]

is not exception-safe because the global file handle FH is not closed when die is called.

A simple remedy is to replace the ugly global FH with a lexical file handle $fh, which is auto-closed at end of scope (RAII):

use strict;
use warnings;
sub fred {
    my $fname = 'f.tmp';
    open( my $fh, '<', $fname ) or die "error: open '$fname': $!";
    print "file '$fname' opened ok\n";
    # ... process file here
    die "oops";   # if something went wrong
    close($fh);
}
my $ok = eval { fred(); 1 };    # see [id://11130946]
if (!$ok) { print "died: $@\n" }
print "ok, \$fh is auto-closed when sub fred exits (normally or via di
+e)\n";
[download]

References Added Later

Some useful recent Perl Monks nodes:

Bug in eval in pre-5.14 by choroba (2016)
Re: Bug in eval in pre-5.28 by haukex (2021) - later response that recommends: my $success = eval { ...; 1 };

Should I use carp/croak or warn/die by SBECK (2018)
Can I catch a die from someone else's module? by bartender1382 (2022) - useful replies from haukex and kcott
canonical doc explaing need for "eval { ... } or do {...}" construct by the LanX (2022) - lots of useful recent info

Re^7: STDERR in Test Results by afoken in response to Bod (2023) - compares Perl to C and analyses DBI RaiseError attribute and transactions
Re^8: STDERR in Test Results by bliako in response to afoken (2023) - likes to return error codes, considering trying exceptions instead
Re^3: SQL: Update column(s) value with extra WHERE by bliako (2023) - some discussion around the performance overhead of throwing exceptions

Perl try { } catch(e) { } by Superfox il Volpone (2015) - trying to implement try { ... } catch { ... } without an external module
try/finally syntax by Superfox il Volpone (2024) - trying to use the new perl v5.38 try/catch/finally syntax with perl v5.34.1

Re^4: Schizophrenic var (semipredicate problem) by me (2023) - how functions can signal errors without using exceptions
New built-in perl5.38 try/catch syntax by me (2023) - a complete working example program using latest perl v5.38 built-in try/catch syntax

EyeBall stumps BodBall (Error Handling) by me (2023) - Exception Handling v Returning a value from a function indicating failure
Re: EyeBall stumps BodBall (Error Handling) by me (2023) - ... with lots of extra references
Re^3: EyeBall stumps BodBall by etj (2024) - mentions Devel::Confess
Re^2: EyeBall stumps BodBall by etj (2024) - notes that GraphQL error handling always returns JSON

Which incarnation of try/catch to use? by mldvx4 (2023)
When to use eval by anonymonk (Feb 2024) - lots of excellent replies
Why causes Exception::Class a fat-packed perl application to fail (but works with 5.38) by Darkwing (Jul 2024) - problem packing Exception::Class with App::FatPacker
Nested Evals in Old Perl 5.10 by mikkoi (Aug 2024)
Re^3: RSS Parsing not working on new machine by wintermute115 (Apr 2025)

Some general advice from On Coding Standards and Code Reviews (API Design Checklist section):
- Error handling. Document all errors in the user's dialect. Prefer throwing exceptions to returning special values. Prefer to find errors at compile time rather than run time.
As noted at On Interfaces and APIs:
- Perl 5's "string eval" and "block eval" is an example of violation of the "principle of distinction", aka "different things should look different"
Some older nodes:
- Best Practices for Exception Handling by Ovid (2003)
- Intelligent Exception Handling in Perl by skynight (2003)
- Writing Solid CPAN Modules by me (2005) - see Exception Safety section
- Re: What is the best way to extend packages with global error handlers? by me (2009) - notes that PBP endorses Exception::Class
- eval to replace die? by hsmyers (2010) - long thread with many heated posts from BrowserUk and responses from chromatic and mithaldu
Some external references:
- mod_perl (wikipedia)
- Exception Handling for mod_perl
CPAN Modules:
- Try::Tiny
- Devel::EvalError
- Exception::Class
- Throwable (especially with Moose or Moo)
- Devel::Confess - include stack traces on all warnings and errors
- Syntax::Keyword::Try by Paul Evans - a try/catch/finally syntax for perl
- Syntax::Keyword::Defer by Paul Evans - execute code when leaving a block (via a defer block)
- Feature::Compat::Try by Paul Evans - make try/catch/finally syntax available. On older versions of perl before such syntax is available, it is provided instead using the Syntax::Keyword::Try module.
- Feature::Compat::Defer by Paul Evans - make defer syntax available. On older versions of perl before such syntax is available, it is provided instead using the Syntax::Keyword::Defer module.
- Perl::MinimumVersion by Dan Book - Find a minimum required version of perl for Perl code (uses PPI)
- Syntax::Construct by choroba - Explicitly state which non-feature constructs are used in the code
Wikipedia:
- Exception handling
- RAII (Resource Acquisition is Initialization) - originated in C++
- Dispose pattern - used in automatic garbage collection languages, such as Java and C#
ISO C++:
- Exceptions and Error Handling (As a rule of thumb, exception handling is extremely cheap when you don't throw an exception. It costs nothing on some implementations. All the cost is incurred when you throw an exception: that is, "normal code" is faster than code using error-return codes and tests. You incur cost only when you have an error)
SO:
- In what ways do c++ exceptions slow down code when there are no exceptions thrown
- Does try catch in C++ affect performance when not hit
See Also
- Re: 5.40 released (perl new feature References)
- Re^7: Meaning of XS object version (Package Manager Security References - example building Perl securely from source)
Updated: added use feature 'try' and Exception Safety and RAII sections. Updated sample code based on Re: Bug in eval in pre-5.28.
Comment on Re: eval to replace die? (Exceptions and Error Handling References)
Select or Download Code


Come for the quick hacks, stay for the epiphanies.
	PerlMonks