$obj->Method()->{key}->@[3,7];
$obj->Method()->{lock}->@{"open","close"};
instead of
@{$obj->Method()->{key}}[3,7];
%{$obj->Method()->{lock}}{"open","close"};
I particularly hate the wide separation of the
@ and the [3,7] above.
But you don't have to use it. I agree that taking
a reference should be prefix and never proposed (nor saw
a proposal for $foo->\. But most of the
dereferencing I do is already postfix via
-> anyway.
If you don't like it, you must be typing:
${${$obj->Method()}{key}}[0];
instead of either of:
$obj->Method()->{key}->[0];
$obj->Method(){key}[0];
The added postfix dereference operators just round things
out so I can use postfix for more than just getting a
single element. Note the nice similarity:
$obj->Method()->{key}->[1]; # One element.
$obj->Method()->{key}->@[1,2]; # Two elements.
I really doubt I'd write $foo->@, reserving
its use for chains of dereferences like above.
Now, the really whacky thing I'd love to see is the
list dereference operator, but that patch is just too
much work for the size of audience who can appreciate it.
It lets you take multi-dimensional slices:
$data->@{qw(this that other)}->>@[3,7]->>Method();
does
my @ret;
for( %{$data}{qw(this that other)} ) {
for( @{$_}[3,7] ) {
push @ret, $_->Method();
}
}
return @ret;
I had a real use for this when I was automating installations
of WindowsNT. To make complex decisions about how to partition
and format hard disks, I built a big data structure that
described tons of details about the current
configuration of your hard disks and partitions. This in
itself was very handy but I kept wanting to do things like:
SavePartnSizes( $info->{Disks}->@->>{Partition}
->>@->>@{"Label","SizeMB"} );
#vs.
my( @partns, %partnSize );
for my $disk ( @{$info->{Disks}} ) {
for my $partn ( @{$disk->{Partition}} ) {
push @partns, $partn->{Label};
$partnSize{$partn->{Label}}= $partn->{SizeMB};
}
}
SavePartnSizes( @partns, @partnSize{@partns} );
It feels a lot like map.
OK, enough rambling. |