Friday, December 17, 2021, marked the thirty-fourth birthdayof the Perl programming language, and coincidentally this year saw the release of version 5.34. There are plenty of Perl developers out there who haven’t kept up with recent (and not-so-recent) improvements to the language and its ecosystem, so I thought I might list a batch. (You may have seen some of these before in May’s post “Perl can do that now!”)
Perl v5.10 was released in December 2007, and with it came feature, a way of enabling new syntax without breaking backward compatibility. You can enable individual features by name (e.g., use feature qw(say fc);for the sayand fckeywords), or by using a feature bundlebased on the Perl version that introduced them. For example, the following:
use feature ':5.34';
…gives you the equivalent of:
use feature qw(bareword_filehandles bitwise current_sub evalbytes fc indirect multidimensional postderef_qq say state switch unicode_eval unicode_strings);
Boy, that’s a mouthful. Feature bundles are good.The corresponding bundle also gets implicitly loadedif you specify a minimum required Perl version, e.g., with use v5.32;. If you use v5.12;or higher, strictmodeis enabled for free. So just say:
use v5.34;
And lastly, one-liners can use the -Eswitchinstead of -eto enable all features for that version of Perl, so you can say the following on the command line:
perl -E 'say "Hello world!"'
Instead of:
perl -e 'print "Hello world!\n"'
Which is great when you’re trying to save some typing.
Sometimes new Perl features need to be driven a couple of releases around the blockbefore their behavior settles. Those experiments are documented in the perlexperiment page, and usually, you need both a use feature(see above) and no warningsstatement to safely enable them. Or you can simply pass a list to use experimentalof the features you want, e.g.:
use experimental qw(isa postderef signatures);
March 2000 saw the release of Perl 5.6, and with it, the expansion of the -wcommand-line switchto a system of fine-grained controls for warning against “dubious constructs” that can be turned on and off depending on the lexical scope. What started as 26 main and 20 subcategorieshas expanded into 31 main and 43 subcategories, including warnings for the aforementioned experimental features.
As the relevant Perl::Critic policy says, “Using warnings, and paying attention to what they say, is probably the single most effective way to improve the quality of your code.” If you must violate warnings (perhaps because you’re rehabilitating some legacy code), you can isolate such violations to a small scope and individual categories. Check out the strictures module on CPANif you’d like to go further and make a safe subset of these categories fatal during development.
Document other recently-introduced syntax with Syntax::Construct
Not every new bit of Perl syntax is enabled with a featureguard. For the rest, there’s E. Choroba’s Syntax::Construct module on CPAN. Rather than having to remember which version of Perl introduced what, Syntax::Construct lets you declare only what you use and provides a helpful error message if someone tries to run your code on an older unsupported version. Between it and the featurepragma, you can prevent many head-scratching moments and give your users a chance to either upgrade or workaround.
Make built-in functions throw exceptions with autodie
Many of Perl’s built-in functions only return false on failure, requiring the developer to check every time whether a file can be opened or a systemcommand executed. The lexical autodiepragmareplaces them with versions that raise an exceptionwith an objectthat can be interrogated for further details. No matter how many functions or methods deep a problem occurs, you can choose to catch it and respond appropriately. This leads us to…
This year’s Perl v5.34 releaseintroduced experimental try/catchsyntaxfor exception handling that should look more familiar to users of other languages while handling the issuessurrounding using block evaland testing of the special $@variable. If you need to remain compatible with older versions of Perl (back to v5.14), just use the Feature::Compat::Try module from CPANto automatically select either v5.34’s native try/catchor a subset of the functionality provided by Syntax::Keyword::Try.
Pluggable keywords
The abovementioned Syntax::Keyword::Try was made possible by the introduction of a pluggable keyword mechanism in 2010’s Perl v5.12. So was the Future::AsyncAwaitasynchronous programming library and the Object::Padtestbed for new object-oriented Perl syntax. If you’re handy with C and Perl’s XS glue language, check out Paul “LeoNerd” Evans’ XS::Parse::Keywordmodule to get a leg up on developing your own syntax module.
Define packages with versions and blocks
Perl v5.12 also helped reduce clutter by enabling a packagenamespace declarationto also include a version number, instead of requiring a separate our $VERSION = ...;v5.14 further refined packages to be specified in code blocks, so a namespace declaration can be the same as a lexical scope. Putting the two together gives you:
package Local::NewHotness v1.2.3 {
...
}
Instead of:
{
package Local::OldAndBusted;
use version 0.77; our $VERSION = version->declare("v1.2.3");
...
}
I know which I’d rather do. (Though you may want to also use Syntax::Construct qw(package-version package-block);to help along with older installations as described above.)
This is an easy win from Perl v5.10:
defined $foo ? $foo : $bar # replace this
$foo // $bar # with this
And:
$foo = $bar unless defined $foo # replace this
$foo //= $bar # with this
Perfect for assigning defaults to variables.
Speaking of variables, ever want one to keep its old value the next time a scope is entered, like in a sub? Declare it with stateinstead of my. Before Perl v5.10, you needed to use a closure instead.
Save some typing with say
Perl v5.10’s bumper crop of enhancementsalso included the sayfunction, which handles the common use case of printing a string or list of strings with a newline. It’s less noise in your code and saves you four characters. What’s not to love?
Note unimplemented code with ...
The ...ellipsis statement(colloquially “yada-yada”) gives you an easy placeholder for yet-to-be-implemented code. It parses OK but will throw an exception if executed. Hopefully, your test coverage(or at least static analysis) will catch it before your users do.
Loop and enumerate arrays with each, keys, and values
The each, keys, and valuesfunctions have always been able to operate on hashes. Perl v5.12 and above make them work on arrays, too.The latter two are mainly for consistency, but you can use eachto iterate over an array’s indices and values at the same time:
while (my ($index, $value) = each @array) {
...
}
This can be problematic in non-trivial loops, but I’ve found it helpful in quick scripts and one-liners.
Ever needed to deletean entry from a hash (e.g, an environment variable from %ENVor a signal handler from %SIG) just inside a block? Perl v5.12 lets you do thatwith delete local.
Paired hash slices
Jumping forward to 2014’s Perl v5.20, the new %foo{'bar', 'baz'}syntaxenables you to slice a subset of a hashwith its keys and values intact. Very helpful for cherry-picking or aggregating many hashes into one. For example:
my %args = (
verbose => 1,
name => 'Mark',
extra => 'pizza',
);
# don't frob the pizza
$my_object->frob( %args{ qw(verbose name) };
Paired array slices
Not to be left out, you can also slice arraysin the same way, in this case returning indices and values:
my @letters = 'a' .. 'z';
my @subset_kv = %letters[16, 5, 18, 12];
# @subset_kv is now (16, 'p', 5, 'e', 18, 'r', 12, 'l')
More readable dereferencing
Perl v5.20 introducedand v5.24 de-experimentalizeda more readable postfix dereferencing syntaxfor navigating nested data structures. Instead of using {braces}or smooshing sigils to the left of identifiers, you can use a postfixed sigil-and-star:
push @$array_ref, 1, 2, 3; # noisy
push @{$array_ref}, 1, 2, 3; # a little easier
push $array_ref->@*, 1, 2, 3; # read from left to right
So much of web development is slinging around and picking apart complicated data structuresvia JSON, so I welcome anything like this to reduce the cognitive load.
whenas a statement modifier
Starting in Perl v5.12, you can use the experimental switch feature’s whenkeyword as a postfix modifier. For example:
for ($foo) {
$a = 1 when /^abc/;
$a = 42 when /^dna/;
...
}
But I don’t recommend when, given, or given’s smartmatchoperations as they were retconned as experiments in 2013’s Perl v5.18and have remained so due to their tricky behavior. I wrote about some alternatives using stable syntaxback in February.
Simple class inheritance with use parent
Sometimes in older object-oriented Perl code, you’ll see use baseas a pragma to establish inheritance from another class. Older still is the direct manipulation of the package’s special @ISAarray. In most cases, both should be avoided in favor of use parent, which was added to core in Perl v5.10.1.
Mind you, if you’re following the Perl object-oriented tutorial’s advice and have selected an OO systemfrom CPAN, use its subclassing mechanism if it has one. Moose, Moo, and Class::Accessor’s “antlers” modeall provide an extendsfunction; Object::Pad provides an :isaattributeon its classkeyword.
Test for class membership with the isaoperator
As an alternative to the isa()methodprovided to all Perl objects, Perl v5.32 introducedthe experimental isainfix operator:
$my_object->isa('Local::MyClass')
# or
$my_object isa Local::MyClass
The latter can take either a bareword class name or string expression, but more importantly, it’s safer as it also returns false if the left argument is undefined or isn’t a blessed object reference. The older isa()method will throw an exception in the former case and might return true if called as a class method when $my_objectis actually a string of a class name that’s the same as or inherits from isa()’s argument.
Introduced in Perl v5.18and de-experimentalized in 2017’s Perl v5.26, you can now precede sub declarations with my, state, or our. One use of the first two is truly private functions and methods, as described in this 2018 Dave Jacoby blogand as part of Neil Bowers’ 2014 surveyof private function techniques.
I’ve writtenand presented extensivelyabout signatures and alternatives over the past year, so I won’t repeat that here. I’ll just add that the Perl 5 Portersdevelopment mailing list has been making a concerted effortover the past month to hash out the remaining issues towards rendering this feature non-experimental. The popular Mojolicious real-time web framework also provides a shortcut for enabling signaturesand uses them extensively in examples.
Indented here-documents with <<~
Perl has had shell-style “here-document” syntaxfor embedding multi-line strings of quoted text for a long time. Starting with Perl v5.26, you can precede the delimiting string with a ~character and Perl will both allow the ending delimiter to be indented as well as strip indentation from the embedded text. This allows for much more readable embedded code such as runs of HTML and SQL. For example:
if ($do_query) {
my $rows_deleted = $dbh->do(<<~'END_SQL', undef, 42);
DELETE FROM table
WHERE status = ?
END_SQL
say "$rows_deleted rows were deleted.";
}
More readable chained comparisons
When I learned math in school, my teachers and textbooks would often describe multiple comparisons and inequalities as a single expression. Unfortunately, when it came time to learn programming every computer language I saw required them to be broken up with a series of and(or &&) operators. With Perl v5.32, this is no more:
if ( $x < $y && $y <= $z ) { ... } # old way
if ( $x < $y <= $z ) { ... } # new way
It’s more concise, less noisy, and more like what regular math looks like.
Self-documenting named regular expression captures
Perl’s expressive regular expressionmatching and text-processing prowess are legendary, although overuse and poor use of readability enhancements often turn people away from them (and Perl in general). We often use regexps for extracting data from a matched pattern. For example:
if ( /Time: (..):(..):(..)/ ) { # parse out values
say "$1 hours, $2 minutes, $3 seconds";
}
Named capture groups, introduced in Perl v5.10, make both the pattern more obvious and retrieval of its data less cryptic:
if ( /Time: (?<hours>..):(?<minutes>..):(?<seconds>..)/ ) {
say "$+{hours} hours, $+{minutes} minutes, $+{seconds} seconds";
}
More readable regexp character classes
The /xregular expression modifier already enables better readability by telling the parser to ignore most whitespace, allowing you to break up complicated patterns into spaced-out groups and multiple lines with code comments. With Perl v5.26 you can specify /xxto also ignore spaces and tabs inside [bracketed]character classes, turning this:
/[d-eg-i3-7]/
/[!@"#$%^&*()=?<>']/
…into this:
/ [d-e g-i 3-7]/xx
/[ ! @ " # $ % ^ & * () = ? <> ' ]/xx
Beginning with Perl v5.14, writing use re '/xms';(or any combination of regular expression modifier flags) will turn on those flags until the end of that lexical scope, saving you the trouble of remembering them every time.
Non-destructive substitution with s///rand tr///r
The s///substitutionand tr///transliterationoperators typically change their input directly, often in conjunction with the =~binding operator:
s/foo/bar/; # changes the first foo to bar in $_
$baz =~ s/foo/bar/; # the same but in $baz
But what if you want to leave the original untouched, such as when processing an array of strings with a map? With Perl v5.14 and above, add the /rflag, which makes the substitution on a copy and returns the result:
my @changed = map { s/foo/bar/r } @original;
Unicode and character encoding in general are complicated beasts. Perl has handled Unicode since v5.6and has kept pace with fixes and support for updated standards in the intervening decades. If you need to test if two strings are equal regardless of case, use the fcfunctionintroduced in Perl v5.16.
Safer processing of file arguments with <<>>
The <>null filehandle or “diamond operator” is often used in whileloopsto process input per line coming either from standard input (e.g., piped from another program) or from a list of files on the command line. Unfortunately, it uses a form of Perl’s openfunctionthat interprets special characters such as pipes (|) that would allow it to insecurely run external commands. Using the <<>>“double diamond” operator introduced in Perl v5.22forces opento treat all command-line arguments as file names only. For older Perls, the perlop documentationrecommends the ARGV::readonly CPAN module.
Safer loading of Perl libraries and modules from @INC
Perl v5.26 removed the ability for all programs to load modules by default from the current directory, closing a security vulnerability originally identified and fixed as CVE-2016–1238in previous versions’ included scripts. If your code relied on this unsafe behavior, the v5.26 release notes include stepson how to adapt.
HTTP::Tinysimple HTTP/1.1 client included
To bootstrap access to CPANon the web in the possible absence of external tools like curlor wget, Perl v5.14 began including the HTTP::Tiny module. You can also use it in your programs if you need a simple web client with no dependencies.
Test2: The next generation of Perl testing frameworks
Forked and refactored from the venerable Test::Builder(the basis for the Test::Morelibrary that many are familiar with), Test2was included in the core module library beginning with Perl v5.26. I’ve experimented recentlywith using the Test2::SuiteCPAN library instead of Test::More and it looks pretty good. I’m also intrigued by Test2::Harness’ support for threading, forking, and preloading modules to reduce test run times.
Task::Kensho: Where to start for recommended Perl modules
This last item may not be included when you install Perl, but it’s where I turn for a collection of well-regarded CPAN modules for accomplishing a wide variety of common tasks spanning from asynchronous programmingto XML. Use it as a starting point or interactivelyselect the mix of libraries appropriate to your project.
And there you have it: a selection of 34 features, enhancements, and improvements for the first 34 years of Perl. What’s your favorite? Did I miss anything? Let me know in the comments.
