An eighth use of local

[rinceWind]

Musing on Mark Jason Dominus's Seven Useful Uses of local, I think I've come up with another one.

The most common use I have for local is with %ENV. The article doesn't specifically mention environment variables. There are instances where I am doing one of the following:

• Forking several times with %ENV{FOO} set to different values, and I need to keep its original or unset value in the parent.

• Writing tests for something that reads an environment variable (see Module::Optional for an example)

• Opening Tk top level windows on multiple displays (see Re: Tk - is MainWindow robust?)

Thinking about it more, I would suggest that @ARGV belongs in the same category, as used in the file slurp idiom:

  my $slurp = do { local (@ARGV, $/) = 'foo.txt'; <>};

There's also localising @ARGV for handling INCLUDE directives in the input stream.

These uses of local could be thought of as a special case of number 6 (Dynamic Scope Revisited), or possibly number 1 (Special Variables), but I think they are a new category.

Update:Looks like there might be a problem with plover.com - try this link as an alernative for MJD's article.

[Ovid]

My most common use of local deals with recursive method calls:

sub foo {
  my $self = shift;
  local $self->{some_val} = $self->get_val;
  # do a bunch of stuff
  $self->foo;
}

This seems strange, but I do find this useful at times. It allows me to temporarily overwrite a value which needs to be preserved for a given stack frame.

[Perl Mouse]

I think that temporary values for elements of aggregates was one of the first 'eigth use's to arise after Mark wrote his article. Probably the most common usage of this is the temporary signal handler.

Note that his article is quite old. For over five years, there has been no need for localized file- or dirhandles. Uses of localized file- and dirhandles could be moved to the last point: relics of the past.

[itub]

%ENV and @ARGV are special variables, so it is indeed a special case of use #1. However, it is good to point it out as a practical example.

[Perl Mouse]

No, it's not a special case of #1. It's a special case of something that's unmentioned: creating temporary values in aggregates. Consider this:

#!/usr/bin/perl

use strict;
use warnings;

my @things = qw /foo bar baz/;

sub do_print {
    print "@things\n";
}

sub show {
    local $things[1] = 'qux';
    do_print;
}

show;
do_print;
__END__
foo qux baz
foo bar baz

In the subroutine show, local is used to temporary set the value of the second element to something else. Upon leaving the block, the old value is restored.

This is not mentioned in Dominus' article, and this is what rinceWind is using. The fact that %ENV is special is irrelevant.

[xdg]

It's a special case of something that's unmentioned: creating temporary values in aggregates.

That's a great point. If you missed it, consider this:

my $item = 'wibble';
my @things = qw /foo bar baz/;

local $things[1] = 'qux'; # Legal
local $item = 'wobble';   # Dies with 'Can't localize lexical variable
+ $item'

[ikegami]

Creating temporary values in aggregates is mentioned under #6 (Dynamic Scope Revisited)

[itub]

Good point. I'd still say that it has a bit of #1 due to the magic of %ENV, but it is true that it is also creating a temporary value for a hash element. The @ARGV example, however, was using "normal" localization and affected the whole array.

[jkeenan1]

Musing on Mark Jason Dominus's Seven Useful Uses of local, I think I've come up with another one.

I got a "404 link not found error" when I clicked on your link. Could you double check? Thanks.

jimk