As you might know, I have been using Perl::Critic on my code over the last several days. After I finished checking my code on the gentle setting, I kicked it up a notch and used stern. Well, Perl::Critic set on stern gave me screens full of problems, and the biggest one is I use the expression form of map and grep. I looked around the web to find out why.

Here is my opinion that could be very wrong.

All of the examples I found of the expression form of map and grep would lead to inevitable problems, and I can see why the writers of those examples would jump on using the block form for both. However, the one thing all of the examples had in common is the disuse of parentheses. I feel that if the expression form of a map or grep is used with parentheses, it is contained within them.

The map below would lead to problems, since there is nothing containing the expression or on which list(s) the map is being applied.

my @colors = qw(red yellow green cyan blue magenta);
my @grey_scale = qw(white grey black);

my @list = map "$_ beads", @colors, @grey_scale;
[download]

However, I do not think this needs a block form to contain the map and list if parentheses are used.

my @list = map( "$_ beads", @colors ), @grey_scale;
[download]

Now the map is contained within parentheses, and @grey_scale does not get beads mapped to it. However, if one must use the block form, parentheses would still be needed to contain the mapped items.

my @list = ( map { "$_ beads" } @colors ), @grey_scale;
[download]

I think the expression form with parentheses is easier on the eyes, but it is just my opinion. I can understand using the block form if the map were more complex, however, I think I would write a separate subroutine instead of loading the block with more than two or three modifications and use the expression form.

sub make_beads {
  my $color = shift;

  if ($color =~ /red|green|blue/) {
    $color .= ' sparkley';
  }
  else {
    $color .= ' shiny';
  }

  $color .= ' beads';

  return $color;
}

my @list = map( make_beads($_), @colors), @grey_scale;
[download]

Converting from expression to block form is also problematic as it is not always as simple as the above would suggest, especially with grep. I have also found the expression form of grep to be easier to use, in one case (I can not remember the specifics) I could not get the block form of grep to work.

If I use sort with map and/or grep on the same list, I will wrestle the block forms until I get the results I want, because in that case, it is easier on my eyes than trying to mix expression forms with the block of sort.

my @list = (
  map  { make_beads($_} }
  sort { $a cmp $b }
  grep { <something> }
  @colors
), @grey_scale;
[download]

I know I can ignore Perl::Critic's results on this and other issues, however, I do want code that is more acceptable by the community. So, I am trying to decide if I want to start wrestling with Perl on this or not. (I ran Perl::Critic on all of my modules, and it found 330 lines where I used the expression forms of map and grep, so this is fairly big to me.)

I hope I am not too wrong about this.