Starting in Perl 5.10, it is now possible to lexically scope the context variable $_
, either explicitly as my $_;
or in a given / when
construct.
Has anyone found good uses of the lexical $_
? Does it make any constructs simpler / safer / faster?
What about situations that it makes more complicated? Has the lexical $_
introduced any bugs into your code? (since control structures that write to $_
will use the lexical version if it is in scope, this can change the behavior of the code if it contains any subroutine calls (due to loss of dynamic scope))
In the end, I'd like to construct a list that clarifies when to use $_
as a lexical, as a global, or when it doesn't matter at all.
NB: as of perl5-5.24
these experimental features are no longer part of perl.
IMO, one great thing to come out of lexical $_
is the new _
prototype symbol.
This allows you to specify a subroutine so that it will take one scalar or if none is provided it will grab $_
.
So instead of writing:
sub foo {
my $arg = @_ ? shift : $_;
# Do stuff with $_
}
I can write:
sub foo(_) {
my $arg = shift;
# Do stuff with $_ or first arg.
}
Not a big change, but it's just that much simpler when I want that behavior. Boilerplate removal is a good thing.
Of course, this has the knock on effect of changing the prototypes of several builtins (eg chr
), which may break some code.
Overall, I welcome lexical $_
. It gives me a tool I can use to limit accidental data munging and bizarre interactions between functions. If I decide to use $_
in the body of a function, by lexicalizing it, I can be sure that whatever code I call, $_
won't be modified in calling code.
Dynamic scope is interesting, but for the most part I want lexical scoping. Add to this the complications around $_
. I've heard dire warnings about the inadvisability of simply doing local $_;
--that it is best to use for ( $foo ) { }
instead. Lexicalized $_
gives me what I want 99 times out of 100 when I have localized $_
by whatever means. Lexical $_
makes a great convenience and readability feature more robust.
The bulk of my work has had to work with perl 5.8, so I haven't had the joy of playing with lexical $_
in larger projects. However, it feels like this will go a long way to make the use of $_
safer, which is a good thing.
I once found an issue (bug would be way too strong of a word) that came up when I was playing around with the Inline
module. This simple script:
use strict qw(vars subs);
for ('function') {
$_->();
}
sub function {
require Inline;
Inline->bind(C => <<'__CODE__');
void foo()
{
}
__CODE__
}
fails with a Modification of a read-only value attempted at /usr/lib/perl5/site_perl/5.10/Inline/C.pm line 380.
error message. Deep in the internals of the Inline
module is a subroutine that wanted to modify $_
, leading to the error message above.
Using
for my $_ ('function') { ...
or otherwise declaring my $_
is a viable workaround to this issue.
(The Inline
module was patched to fix this particular issue).
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With