Re^16: Experimental features: autoderef vs postfix deref

Why not make your straw man ${ ${ $foo->{bar} }{baz} } = 4? A. Because that would be even more stupid.

:-) OK, let's try:

${ $foo->{bar}{baz} } = 4:
[download]

Still looks stupid?

What about:

@{ $foo->{bar}{baz} }[0, 5] = (3, 4);
[download]

I guess, also too stupid?

Let's try some more:

@{ $foo->{bar}{baz} }{ 'John', 'Jane', 'Bill' } = ('Smith') x 3;
[download]

Stupid?

If not, then why

${ $foo->{bar} }{baz} = 4;
[download]

becomes stupid? Maybe because you can actually avoid circumfix dereferencing here?

Why not just $foo->{bar}{baz} = 4; the way 90% of people write it?

That's what I'm asking. Why 90% of people try to avoid circumfix when they can?

Comment on Re^16: Experimental features: autoderef vs postfix deref Select or Download Code

Replies are listed 'Best First'.
Re^17: Experimental features: autoderef vs postfix deref by Anonymous Monk on Jul 14, 2015 at 03:34 UTC
Why 90% of people try to avoid circumfix when they can? They're not "avoiding"; they just not adding what would be pointless. Just as those in favour of postfix deref won't add: `$foo->{bar}->{baz}->$* = 4;`, because that would be equally pointless. So, back to the real argument. When explicit dereferencing is actually required, is `push @{ $foo->{bar}{baz} }, 4;` Simpler, clearer, easier to scan and less ugly than `push $foo->{bar}->{baz}->@*, 4;` And clearly the answer is yes. /c	[reply] [d/l] [select]
Re^18: Experimental features: autoderef vs postfix deref by Anonymous Monk on Jul 14, 2015 at 05:18 UTC
Just as those in favour of postfix deref won't add: `$foo->{bar}->{baz}->$* = 4;`, because that would be equally pointless. :-) What would be pointful instead? (what is the equivalent but pointful expression?) So, back to the real argument. When explicit dereferencing is actually required, is `push @{ $foo->{bar}{baz} }, 4;` Simpler, clearer, easier to scan and less ugly than push `$foo->{bar}->{baz}->@, 4;` Sure, just like `$foo->{bar}{baz} = 4;` [download] is simpler, clearer, easier to scan and less ugly than `${ $foo->{bar} }{baz} = 4;` [download] just like `$foo->{bar}{baz}->@[1, 2, 3] = (100, 200, 500);` [download] is simpler, clearer, easier to scan and less ugly than `@{ $foo->{bar}{baz} }[1, 2, 3] = (100, 200, 500);` [download] just like `$foo->{bar}{baz}->$ = 4;` [download] is simpler, clearer, easier to scan and less ugly than `${ $foo->{bar}{baz} } = 4;` [download] And I think no one is going to take `push @{ stuff }, stuff` away from you? Back to the real point Postderef is good for exactly the same reason that the existing `->` operator is good. Most people prefer to read and write in one direction (such as left-to-right) rather than inside-out. Postderef syntax is especially good for slices - `@{ $foo->{bar} }[1, 2, 3]` is 'pointless' for the same reason that `${ $foo->{bar} }{baz}` is 'pointless'. The reason is inside-out reading. I also don't see why it shouldn't work for the whole thing - you still get to read the expression left-to-right, so it's still just as good. If it works at all, it should work everywhere, including `push`, even if you some find it 'ugly' or 'pointless'.	[reply] [d/l] [select]