Perl v5.26 adds the experimental
declared_refs feature that expands on the experimental
refaliasing feature from v5.22. As with all experimental features, this may change or disappear according to perlpolicy.
Continue reading “Mix assignment and reference aliasing with declared_refs”
Two features that I have previously discouraged are now gone from Perl. The lexical
$_ and auto dereferencing.
$_ was a consequence of the way Perl wanted smart match to work. In a
given-when, instead of aliasing
foreach does, the block had an implicit
my $_ = .... This interfered with the package version, as I wrote about in Use for() instead of given() and Perl v5.16 now sets proper magic on lexical $_. Continue reading “Lexical $_ and autoderef are gone in v5.24”
Perl’s dereferencing syntax might be, or even should be, responsible for people’s disgust at the language. In v5.20, Perl added the experimental postfix dereferencing syntax that made this analogous to method chaining. This is one of the most pleasing Perl features I’ve encountered in years. Continue reading “Postfix dereferencing is stable is v5.24”
Perl v5.22’s experimental
refaliasing feature adds the ability to alias a named variable to another named variable, or alias a named variable to a reference. This doesn’t copy the data; you end up with another named variable for the same data. As with all such features, the details and syntax may change or the feature may be removed all together (according to perlpolicy). Update: Also see v5.26’s
declared_refs experimental feature.
Continue reading “Create named variable aliases with ref aliasing”
[Update: This feature became stable in Perl v5.24]
Perl v5.20 offers an experimental form of dereferencing. Instead of the complicated way I’ll explain in the moment, the new postfix turns a reference into it’s contents. Since this is a new feature, you need to pull it in with the
feature pragma (although this feature in undocumented in the pragma docs) (Item 2. Enable new Perl features when you need them. and turn off the experimental warnings: Continue reading “Use postfix dereferencing”
When you’re using code references heavily, you’re going to have a problem figuring out which one of them is having a problem. You define them in possibly several and far-flung parts of your program, but when it comes to using them, you don’t know which one you are using. You can’t really print its value like you would for a scalar, making it more difficult for you to debug things. You can dereference a scalar or an array to see what it is, but you can’t dereference a code reference without making it do something. Continue reading “Enchant closures for better debugging output”
References aren’t just for data structures, and many people overlook the benefit of references to simple scalars. With references to arrays and hashes you can keep those data structures in tact when you pass them to or return them from subroutines (Item 46: Pass references instead of copies). You don’t need to worry about scalar values because they are a single item in both the non-reference and reference form. Continue reading “Use scalar references to pass large data without copying.”
When you want to make a completely disconnected copy of a hash or an array, it’s not enough to merely assign it to a new variable name, at least in the general case: Continue reading “Make deep copies”