Correct me if I'm wrong, but isn't this more about autovivification than it is about aliasing? Your leading paragraph sounds about right, that aliasing can lead to hard to debug problems. But the meat of your Meditation appears to be an autovivification problem, to my eyes.

Update: I see where the aliasing comes in, but I still think the problem is caused by autovivification. It's all a matter of perspective, really, and I just wanted to explain mine. I suppose this is ambrus' Meditation, and he can say the topic is aliasing if he wants, but that doesn't change my view of the particular example he chose to use.

I disagree, this is not an autovivification problem.

Autovivification happens when you have an undefined scalar, you dereference it in an lvalue context, then a new scalar/array/hash gets allocated, and the formerly undefined scalar is set to a reference to this new scalar/array/hash.

The simplest example to autovivification is this: my $x; $$x = 42; After this, the content of $x is no longer undef, but instead, it's a reference to 42. Similarly, any of these create a new array and sets the scalar to a reference to it:

my $x; @$x = (5, 7);
my $y; $$y[2] = 9;
my $z; @$z[2 .. 4] = (5, 7);
my $w; grep 0, @$w[2 .. 4];
[download]

Now compare this to my example, which was, in its simplest form:

my @x; grep 0, $x[2];
[download]

This has not set any (formerly undefined) scalar to a reference. While it has allocated a scalar, that's for a different reason.

It is an autovivification problem, yes. However, the autovivification occurs due to the aliasing of grep (and map and sort and a few others). That's why aliasing is correctly the focus of this meditation.

---

• In general, if you think something isn't in Perl, try it out, because it usually is. :-)
• "What is the sound of Perl? Is it not the sound of a wall that people have stopped banging their heads against?"

On aliases, I wish Perl had more of 'em. This doesn't really have a lot to do with your meditation, but the topic made it spill out.

I'd like to have lexical variables which are aliases to other values. Currently, you only get that by defining a for loop variable:

my ($foo,$bar,$baz,$i);
for my $quux ($foo, $bar, $baz) {
    $quux = $i++;
}
print "$foo $bar $baz\n";
__END__
0 1 2
[download]

sub wibble {
    return unless @_ > 2;
    my ($string, $position, $count) =
        map { alias } @_;
    # . . .
}
[download]

I expect this sort of thing has been discussed before.

I'd like to have lexical variables which are aliases to other values.

Luckily, there's Perl 6 :)

  my $var    = ...;
  my $alias := $var;   # That's it.

  # Or:
  my $short := %alias_to<a_very>[long()]<name>;
  $short = ...; # Modifies %alias_to
[download]

--Ingo

While I understand that perl6 will have this feature, I belive there will be less need for it because of the other changes in the language.

The times I feel the need of lexical aliases (in perl5) most are nested datastructures and lexical subs.

For example, when I have a ref-to-hash $h, I can only access elements like $$h{"foo"} (or the arrow notation), which is ugly. It would be much simpler to alias it to %h and then I could just access the elements as $h{"foo"}. Of course, you can make a copy like my %h = %$h;, but that can be slow, and you have to copy it back with %$h = %h; if you modifiy %h. In perl6, however, $$h{"foo"} will become $h{"foo"}, which is a simple enough notation so the problem will be gone. (As a sidenote, there are nonstandard modules for perl5 that allow lexical aliasing.)

Lexical subs are very similar. Today, the way to create lexical subs is my $frobnicate = sub { ... }; and we call them by &$frobnicate(@args) (or the arrow notation), which is, again, ugly. In perl6, this shall simplify to $frobnicate(@args).

Of course, perl6 will have lexical aliases like my %h := %$h and true lexical &-variables in addition to $, @, % so you can use aliasing to solve either of these too. TIMTOWTDI.

Update: lexical aliases wouldn't solve my second problem. We'd need lexical subs for that.

Perl6 also won't need the arrow notation to dereference values:

my %hash = (a => 1, b => 2);
my $href = \%hash;

say %hash<a>++; # prints 1
say $href<a>;   # prints 2
[download]

Update: noticed ambrus already mentioned that. Sorry for the repitition. :-)

Perhaps I've missunderstood your post, but what do aliases get you that references don't? Slightly nicer syntax?

Compare the output from these two snippets:

$ pugs -e 'my %hash;
           %hash<foo>[0]<bar>[0] = 1;
           my $alias := %hash<foo>[0];
           say ref $alias;
           %hash<foo>[0] = 5;
           say ref $alias'
Hash
Int

$ pugs -e 'my %hash;
           %hash<foo>[0]<bar>[0] = 1;
           my $ref = %hash<foo>[0];
           say ref $ref;
           %hash<foo>[0] = 5;
           say ref $ref'
Hash
Hash
[download]