-- Randal L. Schwartz, Perl hacker

Sorry, merlyn, but the second example *is* turning a list into another list. map is very capable of mapping 1-to-n relations, ie, every element on the right will produce more than one element on the right.

If I read your statement correctly ( and I may not have ), the first use of map isn't correct

my @first = qw/ one-1 two-2 three-3/;
my %hash  = map { split /-/ } @first; # Which works for me btw
print map { "$_ => $hash{$_}\n" } keys %hash;
[download]

But this usage is correct

my @first = qw/ one-1 two-2 three-3/;
my @second  = map { split /-/ } @first;
my %hash = @second;  # Legal code, isn't it?
print map { "$_ => $hash{$_}\n" } keys %hash;
[download]

How else is map supposed to make @first into @second except by performing an action on every element of @first?

I am not arguing that a foreach wouldn't be appropriate here. If that is what works, by all means use it. But if I am not supposed to use map when I want an action on every element of an array, doesn't it make more sense to say

@second = @first;
[download]

because that seems to be the only option you have left me with this statement.

Would you be kind enough to expand on your answer so I can figure out what I missed?

TIA
mikfire

I wasn't commenting on either of those. I was commenting on the original poster's last example:

if ($access) { 
    foreach (@{$access}) { 
        $set{$_->[0]} = $_->[1]; 
    } 
}
[download]

That's just fine as it is. No need for a map. In fact, a map would be difficult here, unless we presume %set is already empty before we get here.

-- Randal L. Schwartz, Perl hacker

Out of interest, why does this (both examples) print:

one => 1
three => 3
two => 2
[download]

and not:

one => 1
two => 2
three => 3
[download]

if ($access) {
      foreach (@{$access}) {
          $set{$_->[0]} = $_->[1];
      }
  }
[download]

    %set = map {($_->[0], $_->[1])} @$access;
[download]

use strict;

my @start_list = (qw/ one two three four five six /);
my $function = sub { uc };

my @end_list = fake_map( $function, @start_list );
#equivalent to @end_list = map { &$function } @start_list;

my %end_hash = fake_map( $function, @start_list );
#equivalent to %end_hash = map { &$function } @start_list;

print (join (' ', @end_list, "\n") );
foreach (keys %end_hash) {
  print "hash{'$_'} = $end_hash{$_}\n";
}

sub fake_map {
  my $func = shift;
  my @instack = @_;
  my @outstack = ();
  foreach (@instack) {
    push (@outstack, &$func);
  }
  return @outstack;
}
[download]

`map EXPR, LIST' is in general quite a bit faster than `map BLOCK LIST', so you should probably try to use EXPRs rather than BLOCKs whenever possible in a map.

For instance, here are your first examples recoded as EXPRs:

my @adjusted_array = map $_ * 10, @array;

my %hash = map split /-/, @array;

Why is it faster? Using the BLOCK introduces a new scope, which adds some extra ops and time to start and finish. BLOCKs do give you extra power and flexibility, but try to use them only when necessary.

-dlc

Why is it faster?

Because the optimizer is "broken". (:

        - tye (but my friends call me "Tye")

Question for the monks:

Isn't it true you could do something like this (even though it's probably not in keeping with the intent of map)?

# a way to count the number of elements in a list
my $count = 0;
my @listOfThings = ('one', 'two', 'three');
map { ++$count } @listOfThings;
print "There are $count things in your list of things.\n";
[download]

This example completely ignores the fact that the elements in the list are assigned to $_. We could care less what was in those elements. All we want to do is to execute this block once for each element that is in the list.

I'd just write that as

++$count for @listOfThings;
[download]

Shorter even. {grin}

And yeah, for this specific example, I wouldn't even use a loop, as in:

$count += @listOfThings;
[download]

-- Randal L. Schwartz, Perl hacker

Of course...

I just wanted to point out that you don't have to really do anything with the elements of @listOfThings if you don't want to; you can do something completely unrelated.

As an aside, and you may call this trolling (or you may not), I just wanted to see what people would say about this sort of use of map. It's probably a Bad Idea. It would be really interesting to see if somebody could convince me it's a Good Idea. :-)