The Perl Advent Calendar needs more articles for 2022. Submit your idea today!

NAME

Feature::Compat::Defer - make defer syntax available

SYNOPSIS

   use Feature::Compat::Defer;

   {
      my $dbh = DBI->connect( ... ) or die "Cannot connect";
      defer { $dbh->disconnect; }

      my $sth = $dbh->prepare( ... ) or die "Cannot prepare";
      defer { $sth->finish; }

      ...
   }

DESCRIPTION

This module provides a new syntax keyword, defer, in a forward-compatible way.

The latest perl development source provides a defer block syntax, under the defer named feature. If all goes well, this will become available at development version 5.35.4, and included in the 5.36 release. On such perls, this module simply enables that feature.

On older versions of perl before such syntax is available. this module will instead depend on and use Syntax::Keyword::Defer to provide it.

KEYWORDS

defer

   defer {
      STATEMENTS...
   }

The defer keyword introduces a block which runs its code body at the time that its immediately surrounding code block finishes.

When the defer statement is encountered, the body of the code block is pushed to a queue of pending operations, which is then flushed when the surrounding block finishes for any reason - either by implicit fallthrough, or explicit termination by return, die or any of the loop control statements next, last or redo.

For more information, see additionally the documentation in "defer" in Syntax::Keyword::Defer and, on a recent enough perl, "defer blocks" in perlsyn.

COMPATIBILITY NOTES

This module may use either Syntax::Keyword::Defer or the perl core defer feature to implement its syntax. While the two behave very similarly, and both conform to the description given above, the following differences should be noted.

  • Double Exceptions

    Because defer blocks will run during stack unwind because of exception propagation it is possible to encounter a second exception within the block, thus having two "in flight" at once. Neither Syntax::Keyword::Defer nor core's defer feature currently guarantees what exception will be seen by the caller in such a situation, other than that some kind of exception will definitely happen.

    In particular, you should not rely on definitely receiving either the first, or the final exception, in this situation.

  • Fragile Against Erroneous Control Flow

    The core defer feature tries hard to forbid various kinds of problematic control that jumps into or out of defer blocks. In particular, things like using last to jump out of a control loop that is outside the defer block are banned.

    By comparison, there is less that Syntax::Keyword::Defer can do about this situation because it does not have access to as many parser and compiler tricks as the core implementation. Therefore, there are some situations that the core feature can prohibit statically, that Syntax::Keyword::Defer can only detect at runtime - if at all. There may be odd cases where prohibited behaviour performs differently between the two implementations.

    As long as you don't do anything "weird" like using loop controls or goto to abuse the flow of control into or out of a defer block, this should not cause a problem.

AUTHOR

Paul Evans <leonerd@leonerd.org.uk>