Perl: is there something better than $var = $_;? - perl

Question

It is not important question and I know it, buuut $var = $_; looks just lame, is there better (shorter) way to make that assignment?
To clarify my question: I know I can use $_ in code easily (thats why I like it), but sometimes I need to store $_ and do something on $_ and then get back old value of $_ (for example).

Answer 1

Within a new lexical scope, you can localise $_ which will prevent any modifications within that scope from affecting its value outside that scope.
An example is necessary for clarification:
$_ = 1;
say;
{ # open a new scope
local $_ = 3;
$_++;
say;
} # close the scope
say;
This should print
1
4
1
I find it invaluable for writing functions which make extensive use of $_ internally, because I don't like it when they clobber $_ in their surrounding scope. However, you can also use it to 'set aside' a variable and work with a new version of it for a while.

Answer 2

In many circumstances it's unnecessary. For example:
foreach my $var (#array) {
dostuff($var);
}
or
my $var;
while ($var = <>) {
chomp($var);
dostuff($var);
}
or
while (<>) {
chomp;
dostuff($_);
}

Answer 3

By the OPs request, I am posting my comment as an answer.
It looks like you are asking if there is a better or shorter way to write $var = $_ (or get that functionality). To me, that is a rather strange request, because:
$var = $_ is already about as short as it gets, and
there is no better way to make that assignment than using the equal
sign.

Answer 4

Why do you want $var = $_? Just use $_ or pass it in as a parameter to the function, in the function call it $var.

Answer 5

Use local:
$_ = 1;
{
local $_ = 2;
say; # prints 2
}
say; # prints 1

Answer 6

Maybe the function commonly named apply is what you are looking for. Apply is just like map except it makes a copy of its arguments first:
apply {CODE} LIST
apply a function that modifies $_ to a shallow copy of LIST and returns the copy
print join ", " => apply {s/$/ one/} "this", "and that";
> this one, and that one
Here's an implementation from one of my modules:
http://search.cpan.org/perldoc?List::Gen#apply

Answer 7

All good answers. I'd like to contribute with one more example related to "just use $_" as #awm said.
10 minutes ago I just wrote these lines:
sub composite
{
foreach my $element (#_)
{
# do something ...
}
}
sub simple
{
&composite( $_[ int rand #_ ] );
}
which is a Perl Golf (cit.) , not recommended to use at all.
If you need to store $_ somewhere else and after some time use it's original value you should perform the assignment.

Answer 8

You can use map to generate a new array by transforming an existing array:
my #squares = map { $_**2 } 1..10 ; # 1,4,9,16,25,36,49,64,81,100
my #after = map { process($_) } #before ; # #before unchanged, #after created

Answer 9

It seems like you would like to access the pushdown stack of the $_ local values. That could be cool. However, you can do something like this yourself. I can show you the basics.
our #A; # declare a stack
*::A = *A{ARRAY}; # "Globalize" it if necessary.
sub pd (&;#) # <- block operator prototype indicating language sugar
{
# I would have really preferred to do a push here.
local #A = ( #A, $_ );
# pull the block argument
my $block = shift;
# Ensure at least one execution
#_ = $_ unless #_;
# + Scalar behavior option #1
# return $block->( local $_ = shift ) if not wantarray // 1;
# + Scalar behavior option #2
# unless ( wantarray // 1 ) {
# my $result;
# while ( #_ ) {
# local $_ = shift;
# return $result if defined( $result = $block->( $_ ));
# }
# return;
# }
# Standard filter logic
return map { $block->( $_ ) } #_;
}
And here is a simple list comprehension based on this:
my #comp
= map { pd { pd { join '', #A[-2,-1], $_ } qw<g h> } qw<d e f>; } qw<a b c>
;
Here's #comp:
#comp: [
'adg',
'adh',
'aeg',
'aeh',
'afg',
'afh',
'bdg',
'bdh',
'beg',
'beh',
'bfg',
'bfh',
'cdg',
'cdh',
'ceg',
'ceh',
'cfg',
'cfh'
]