Sometimes a picture paints a thousand words, so here's a contrived example of what I'm getting at with respect to using local to allow changes to a data structure without letting those changes propagate outward (as a possible alternative to the thought "I need to clone this."):

use Data::Dumper;
$Data::Dumper::Sortkeys = 1;
$Data::Dumper::Indent   = 0;

my $args = {
    foo => 1,
    baz => 2,
};

print "Before calling mysub(\$args)\n";
print Dumper($args), "\n\n";

mysub($args);

print "After calling mysub(\$args)\n";
print Dumper($args), "\n\n";

sub mysub {
    my $args = shift;
    local $args->{'foo'} = $args->{'foo'};
    $args->{'foo'} += 100; # 101 now.
    print "Inside mysub()\n";
    print Dumper($args), "\n\n";
    othersub($args);
}

sub othersub {
    my $args = shift;
    local $args->{'baz'};
    delete $args->{'baz'};
    print "Inside othersub()\n";
    print Dumper($args), "\n\n";
}
[download]

This produces the following output:

Before calling mysub($args)
$VAR1 = {'baz' => 2,'foo' => 1};

Inside mysub()
$VAR1 = {'baz' => 2,'foo' => 101};

Inside othersub()
$VAR1 = {'foo' => 101};

After calling mysub($args)
$VAR1 = {'baz' => 2,'foo' => 1};
[download]

So with local we've been able to make changes to individual elements within the $args data structure without those changes propagating back out to the caller's data structure. In cases where the number of changes is small, you can use this sort of strategy rather than deep cloning the entire structure. However, there certainly are many legitimate uses for a deep clone, and the localization of structure elements is not the right tool for every situation. I just wanted to present it as one tool that may be useful in some cases.

Thanks. local is one of those keywords that you'll often read about but rarely stop to think when it can be used when you are actually writing code.

$PM = "Perl Monk's";
$MCF = "Most Clueless Friar Abbot Bishop Pontiff Deacon Curate Priest Vicar";
$nysus = $PM . ' ' . $MCF;
Click here if you love Perl Monks