Unroll it, bit by bit:

Essentially, the code is equivilent to the following, but avoids the %args variable:

sub foobar {
  my %args = @_;
  my $foo = $args{foo};
  my $bar = $args{bar};
}
[download]

perl -pe '"I lo*`+$^X$\"$]!$/"=~m%(.*)%s;$_=$1;y^`+*^e v^#$&V"+@( NO CARRIER'

In my opinion, your translation is a whole lot easier to read and probably a better idea for maintainable code. The original is pretty obfuscated and would definitely confuse a beginner.

I would agree. The only "advantage" to doing the hashref / dereference / slice trick is that one avoids the %args hash; frankly, I don't consider that an advantage at all. Most of the time when I pass args to a function as a hash, I simply use the %args hash in the function, instead of pulling specific values out and stuffing them into scalars. I like to think that this makes for better maintainability and scalability.

But to each their own..

perl -pe '"I lo*`+$^X$\"$]!$/"=~m%(.*)%s;$_=$1;y^`+*^e v^#$&V"+@( NO CARRIER'

Entire arrays (and slices of arrays and hashes) are denoted by '@', which works much like the word "these" or "those" does in English, in that it indicates multiple values are expected.

           @days               # ($days[0], $days[1],... $days[n])
           @days[3,4,5]        # same as ($days[3],$days[4],$days[5])
           @days{'a','c'}      # same as ($days{'a'},$days{'c'})
[download]

my ($foo, $bar) = @{ {foo => "a", bar => "b"} }{ 'foo','bar'}
[download]

which is essentially the same as ($passed_values{'foo'},$passed_values{'bar'}) It's just unusual because we don't use the @variable{'a','b'} form terribly often.

I use this alot but I have never been able to understand exactly what was going on it there

this is called cargo-cult programming. be very careful of this practice. as stated in that link,

One of our illustrious members once had the habit of crying "cargo cult!" whenever he saw someone cut and paste a code snippet into a program. In particular, he was decrying the habit of cutting and pasting bad code. But even cutting and pasting good code is not necessarily a good thing.

this code is bad for maintainence, because it's fragile. its not obvious at first glance that the quoted words are assigned to the lvalues, because they're mapped through an obfuscated route.

better alternatives include the translations provided by swiftone and Chmrr, especially Chmrr's. it's straight forward, direct, and its format allows easy modification.

although your code provides an interesting use of anonymous data structures and slices, i would never use it in production code.

~Particle ;Þ

Well, first I have never used, nor seen this code, so it is probably not that common.

It is quite clever though: it lets you call foobar with named parameters passed through a hash: use foobar( bar => 'value of bar', foo => 'this is foo') and $foo will be 'this is foo' and $bar will be 'value of bar'.

What happens is that %{{@_}} takes @_ and turns it into a hash: the content of @_ ({@_}) is used to create an anonymous hash (%{{@_}}). But what you really want here is only the values, not the keys from this hash, so all (!) you have to do is take a slice of this hash: @{{@_}}{'foo', 'bar'} is the list of values associated to the keys foo and bar in the hash.

Sweet!