Beefy Boxes and Bandwidth Generously Provided by pair Networks
good chemistry is complicated,
and a little bit messy -LW
 
PerlMonks  

Re: keys function question

by cwest (Friar)
on Jul 20, 2000 at 22:58 UTC ( #23469=note: print w/ replies, xml ) Need Help??


in reply to keys function question

keys %{$obj->{param}}
Enjoy!
--
Casey


Comment on Re: keys function question
Download Code
Postfix, whole-object dereference operators
by tye (Cardinal) on Jul 21, 2000 at 01:20 UTC

    Okay, so I left off the "Enjoy!" and so ctweten's has gotten more votes than mine. ;)

    This discussion has been so short and to the point, I thought I'd add a bit...

    I dislike having to use the %{...} syntax as it is hard to read. One solution is:

    $ref= $obj->{param}; for( keys %$ref ) { Mung( $ref->{$_} ); }
    But what we really need is a post-fix operator that give you the whole hash (or array, or scalar, etc.) from a reference:
    my @keys= keys $obj->{param}->%;
    This was proposed on perl5-porters a while back but noone has submitted a patch (as far as I know) to implement it. So here is your chance to become famous. Go to the perl5-porters archive and read up on the proposal and you've got a great project for learning Perl guts.

      Oh C'mon, I voted you up, now you're winning :-)

      I'll have a few spare tuits comming soon.

      I'll have a look at this, sounds fun!

      I've never hacked Perl guts before but I'm willing to give it a shot.

      print foreach $r->%; print foreach $r->@; print foreach $r->$; print foreach $r->*;
      Enjoy! :-)
      --
      Casey
      
      I disagree. Referencing and derefencing should be pre-fix, and if you don't like the SIGIL{} syntax, add whitespace. $foo->\ is silly-looking. \$foo is not. $foo->% also looks silly to me, and if %$foo is too noisy, do %{ $foo }.
        I think he's directly refering to the situation where you have a few references in a row, particularly in hashes... I too, think this is ugly:
        %{$ref->[0]->{param}->[1]->{name}};
        and you can't do this:
        %$ref->[0]->{param}->[1]->{name};
        so, I think it's a gripe about the ugly looks of the syntax. IMHO, I don't mind it, I consider it something like "Variable Encapsulation" in syntax. However, I could see a secondary syntax, as a prefix.

        Perhaps:

        print foreach HASH $obj->{param}; # or we don't like barewords print foreach 'HASH' $obj->{param}; # or parhaps it's really in a prag +ma use dereference qw/HASH/; print foreach HASH $obj->{param}; # or it stays the same print foreach %{$obj->{param}};
        --
        Casey
        

        As another noted, the worst case isn't when you have something simple like $foo. Plus, I didn't mention the other postfix dereference operators flavors:

        $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.

Log In?
Username:
Password:

What's my password?
Create A New User
Node Status?
node history
Node Type: note [id://23469]
help
Chatterbox?
and the web crawler heard nothing...

How do I use this? | Other CB clients
Other Users?
Others romping around the Monastery: (3)
As of 2014-09-19 21:54 GMT
Sections?
Information?
Find Nodes?
Leftovers?
    Voting Booth?

    How do you remember the number of days in each month?











    Results (147 votes), past polls