I have a CPAN module Syntax::Keyword::Try, which provides a try/catch syntax using the keyword plugin mechanism: use Syntax::Keyword::Try; sub foo { try { attempt_a_thing(); return "success"; } catch { warn "It failed - $@"; return "failure"; } } -- https://metacpan.org/pod/Syntax::Keyword::Try This has become the preferred try/catch module in several places, such as recommended by Freenode/#perl, several companies I work or have contracted for, and has been battle-tested in production for a large amount of accumulated time now. I believe it is stable and useful. During the recent(ish) P5H meeting in Amsterdam, this module was mentioned as an example of syntax extension on CPAN that ought to become core in some fashion or other. I would like to open this discussion here. The words "become core" could mean a couple of different things here, so it's important to list them to distinguish them for further discussion: 1) Does core simply bundle the CPAN module as-is, to make it dual-life and shipped with core by default, and to stand as a possible in-core example of how to use the keyword mechanism? 2) Does core reïmplement the exact behavior and semantics of the module as real core code, guarded by some feature perhaps use feature 'try'; at which point, the `sub import` in my existing Try.pm can simply trigger that instead, and the XS part of the module becomes a legacy implementation only required for older perls? I would like to vote in favour of the second option; that core perl actually implement a real try/catch syntax which is syntactically and semantically compatible with the battle-tested S:K:T as it currently stands. At that point the CPAN vs core implementations really ought to remain aligned in terms of features and behaviour, but as I am likely to be the implementer of both I feel that would not be a difficult task to maintain during the "dual-life" lifetime - with the view that one day far into the future, the CPAN version is no longer needed as any reasonable Perl version already supports it in core. A real core implementation of this module could be implemented a little more efficiently in places than my current XS attempt, and could also allow a few new advantages; things I cannot implement in XS as it stands: *) list-returning `try do { ... }` semantics. Currently S:K:T can only provide scalar context, because op_contextualize() gets confused about the optrees that I make and annotates the final internal expression within the block as G_SCALAR *) unhandled `catch` can propagate to outer contexts. Currently S:K:T's implementation is forced to catch all exceptions. Any type checking/dispatch must be implemented in user code, and any exceptions not otherwise handled must be re-thrown. This throws away information. The module currently lacks a type-dispatch mechanism, but if one were added then a core implementation would be able to decide not to catch a given exception and allow it to propagate to callers without needing to be re-thrown. There are still some outstanding syntax questions on how a type dispatch mechanism might be written, but exactly how I attack and answer those will depend in part on what the ultimate destination for the syntax is. Will S:K:T be forever a CPAN module outside of core, or can we find a way to bring it into core for real, and finally[*] bring a real try/catch syntax to the Perl5 language? *: Pardon the pun, I couldn't resist... -- Paul "LeoNerd" Evans leonerd@leonerd.org.uk | https://metacpan.org/author/PEVANS http://www.leonerd.org.uk/ | https://www.tindie.com/stores/leonerd/Thread Next