Is the same true if you use an intermediate variable - does it get aliased, or merely assigned?

my $one = "wired";
for my $two (grep 1, substr($one, 1, 3)) {
  sub { $_[0] = "eir" } -> ($two);
}
print $one;
[download]

-- Randal L. Schwartz, Perl hacker

More weirdness:

my @l = 1..9;
$_ = "foo" for grep $_ % 2, sort reverse @l;
print "@l\n";
[download]

   MeowChow                                   
               s aamecha.s a..a\u$&owag.print

In answer to your first question, yes, named intermediate variables are in fact alises to the list elements (which means you need to watch for modifying constants).

Second question. Yes, Perl 6 gets named parameters, and the ability to truly parse subs as builtins (except perhaps the current print FILEHANDLE LIST semantics). Check out the Apocylypses.

Light a man a fire, he's warm for a day. Catch a man on fire, and he's warm for the rest of his life. - Terry Pratchet

Update: Alright, my question doesn't quite answer your second question. I'm sorry, I got confused on what you meant by "pass by name". :-( I just sent a message asking for clarification to the Perl 6 language group.

Yes, Perl 6 gets named parameters, and the ability to truly parse subs as builtins (except perhaps the current print FILEHANDLE LIST semantics).

print FILEHANDLE LIST will be gone. FILEHANDLE.print(LIST) (or print FILEHANDLE : LIST) is the new syntax, as filehandles are objects.

IFF I understand correctly.

- Yes, I reinvent wheels.
- Spam: Visit eurotraQ.

We use a space where a comma is expected to disambiguate between several (slightly obscure) constructs. For example, indirect object notation. Of course, this is totally supportable with the lexical parsing rules changes (yum). However, the language doesn't seem to directly support user defined methods using this trick themselves.

Cheers,
Erik

Light a man a fire, he's warm for a day. Catch a man on fire, and he's warm for the rest of his life. - Terry Pratchet

$ perl -e'my @foo=(1,2,3,4); for $bar (@foo) { $bar++ } print "@foo\n"
+'
2 3 4 5
[download]

Makeshifts last the longest.

So, if you want modifiable scalar parameters, you can change them inside a sub by using $_[0], $_1 etc. as lvalues without resorting to references. Interesting.

Hehe, I have another word for it. I discovered this a couple of months ago and was really blown away because it means that even if you explicitly pass by value, there's no guarantee that your data won't be altered.

Now despite a natural inclination toward "const correctness" (by which I mean maintaining control over what happens to one's data even when passing it by reference to other folk's functions), I've come to live with Perl's motto that you should keep people out of the living room by asking rather than by wielding a shotgun. But this seems like putting the TV right out in the front lawn. So, my question is why is this allowed? Is this a remnant from Perl 4? Will it be maintained in Perl 6?

If you really, really need to, you can still force "const correctness", but like using closures to force total object data encapsulation, it takes extra effort for both the programmer and Perl.

sub inc {
    $_[0]++
}

my ($i,$j) = (0,0);

inc(@{[$i]});
inc($j);

print"$i $j\n";'

=output
0 1
[download]

____________
Makeshifts last the longest.

use strict;
my $name;
foreach $name (qw/alfred benjamin casey donald eugene/)
{
        print "$name\n";
}
print "*$name*\n";
[download]

use strict;
my $name;

foreach my $loopname (qw/alfred benjamin casey donald eugene/)
{
        $name = $loopname;
        print "$name\n";
}
print "*$name*\n";
[download]

;)

jarich

I prefer it this way - in more traditional languages, I've actually been bitten by the existance of this side effect (or the desire to to use it cleverly). Not having this side effect may seem more awkward, but IMHO makes the code less kludgy and hackish.

Makeshifts last the longest.