#!/usr/local/bin/perl -w
use strict;
use Data::Dumper;

my $row = { title => 'Part1' };

my $parts = [ 'Part1', 'Part2','Part3' ];

my $newLoop = [ grep { $_->{SELECTED}++
                  if $_->{PARTNAME} eq $row->{title}; $_ }
                map +{ 'PARTNAME' => $_ }, @$parts ] ;

warn Dumper($newLoop);
__END__
$VAR1 = [
          {
            'SELECTED' => 1,
            'PARTNAME' => 'Part1'
          },
          {
            'PARTNAME' => 'Part2'
          },
          {
            'PARTNAME' => 'Part3'
          }
        ];
[download]

update2: demonstration:

#!/usr/local/bin/perl -w
use strict;
use Data::Dumper;

my $row = { title => 'Part1' };

my $parts = [ 'Part1', 'Part2','Part3' ];

my $newLoop = [ map
    +{  
        'PARTNAME' => $_,
        $row->{title} eq $_ ? ('SELECTED' => 1) : (),
    }, @$parts ] ;

warn Dumper($newLoop);
[download]

thanks for update2. it's what i needed, and i hadn't even thought of doing the check in the list construction using map

I think it would be a bit more readable like this:

my $newLoop = [ 
    map {$_ eq $row->{title} ? {'PARTNAME' => $_, 'SELECTED' => 1} : {
+'PARTNAME' => $_} } @$parts 
] ;
#or even
my $newLoop = [ 
    map {
        if($_ eq $row->{title}) {
            {'PARTNAME' => $_, 'SELECTED' => 1} 
        } else { 
            {'PARTNAME' => $_} 
        } 
    } @$parts 
] ;
[download]

Jenda


We'd like to help you learn to help yourself Look around you, all you see are sympathetic eyes Stroll around the grounds until you feel at home    -- P. Simon in Mrs. Robinson

I'm as big a fan of grep and map as the next guy, but sometimes they just don't make sense. In this case, I think a plain for loop would be clearer:

my $parts = [ 'Part1', 'Part2','Part3' ];
my $newLoop;

for (@$parts) {
  my $hash = { PARTNAME => $_ };

  $hash->{SELECTED}++
      if $_ eq $row->{title};

  push @$newLoop, $hash;
}
[download]

Or, if anything, just a single map call, but this demonstrates why I prefer the for loop:

my $parts = [ 'Part1', 'Part2','Part3' ];
my $newLoop = [ map {{ PARTNAME => $_,
                        $_ eq $row->{title}
                           ? (SELECTED => 1)
                           : ()
                    }} @$parts ];
[download]

Update: Joost beat me to the punch on the single-map part, but I still prefer my first snippet.

Update: Joost beat me to the punch on the single-map part, but I still prefer my first snippet.

I prefer your first snipped too :-) map can get too complicated. my example is probably on the edge of where I would consider using it.

"What should it profit a man, if he should win a flame war, yet lose his cool?"

the straight map loop is the most concise, i think, plus i need to work more with some of the added list ops.

i just want to extend my working knowledge of everything.

the straight map loop is the most concise, i think

The most concise solution is not always the best. Take a look at any Perl Golf contest for conclusive proof of this. :-) For example, here's another concise version:

my $newLoop;
push @{$newLoop},{PARTNAME=>$_,/$row->{title}/?(SELECTED=>1):()}
for qw(Part1 Part2 Part3);
[download]

But if I saw that in real code, I wouldn't be very happy.

plus i need to work more with some of the added list ops. i just want to extend my working knowledge of everything.

That's fine, but part of learning how to work with something is learning when not to use it. I can't say the map verion that Joost and I both came up with is the worst code I've seen, but it isn't particularly clear. So, learn how to use map, but also learn when to use something else.

...Then your map has only one possible key, so it can have only one element. Apparently, this isn't enough to match the grep, so you get an empty list.

Update: Er, no, map returns a list, not a hash. I tend to forget that :) All odd-numbered elements will be identical, though.