There must be a logical technical reason to how it should/could work. grep reads a list and checks for which ones the condition evaluates to true. That's all. That doesn't look very useful.

Now you're try this with map, it'll build a list of return values instead. Now what would the value returned from the regexp be? Why, you have capturing parens, map calls the regexp in list context, so it'll return an empty list for no match, and a list of captured values for matches. So

@result = map /\w{3}_(\w)/, @inp;
[download]

If you foreach through that list, you can use each as a hash key, in turn. So this will do what you want:

$inp{$_} = 1 foreach map /\w{3}_(\w)/, @inp;
[download]

It looks close to what you made up, but it isn't. Not really.

OK, al that makes me understand map and grep better. I just realized that I want it a little bit different, I need a hash with the same keys but the values should be the whole string, so you would get:

$inp{A} = 'abc_A_bla' ;
etc
[download]

Is this still possible with map or should I switch to a simpel foreach

foreach ( @inp ) {
     ($key) = $_ =~ /\w{3}_(\w)/ ; 
      $inp{$key} = $_ ;
}
[download]

?

Luca

It's still possible but you'll have to use something closer to what sonofason wrote. For each match, you need to create a ($key, $value) pair so the list constructed by map is more like ($key1, $value1, $key2, $value2, $key2, $value3) for the three values. That way, assigning to the hash will insert them as you want.

Now the code you can use to do that, can read for example:

@flat = map { /\w{3}_(\w)/ ? ($1, $_) : () } @inp;
[download]

It'll create a pair like ("A", "abc_A_bla") for a match, and an empty list for no match.

Assign to the hash, and you get:

%inp = map { /\w{3}_(\w)/ ? ($1, $_) : () } @inp;
[download]

my @inp = ("abc_A_bla", "abc_B_bla", "abc_C_bla");

my %inp = map { /\w{3}_(\w)/; $1 => $_ } @inp ;

foreach ( keys %inp ) {
    print "$_ => $inp{$_}\n";
}
[download]

Update: Better to use bart's version which includes checks for when the regex doesn't match.

--
<http://dave.org.uk>

"The first rule of Perl club is you do not talk about Perl club."
-- Chip Salzenberg

A quick rule of thumb which might help to decide if you want grep or map.

If you have a list and you want to filter that list so that you don't get back all of the items, then you probably want grep.

If you have a list and you want to transform each item in the list in some way then you probably want map.

Generally speaking, given a list with N items, grep returns a list with <= N items and map returns a list with N items[1]

[1] Yes, I know that map can actually return more than N items and even less than N items - but my explaination is true to a first approximation.

Try using map instead:

I expect there are plenty of 'use map!' replies before I finish this, but I'll throw my torch light on the subject.

This is initially syntactically wrong. You have a list and need to iterate over it somehow.

my @inp = ("abc_A_bla", "abc_B_bla", "abc_C_bla") ;

print  "@{[ keys %{{ unpack '(x4 A A4)*', pack( '(A*)*', @inp) }}]}";
[download]

map was probably invented for this kind of reason. But the example doesn't really demand it that strongly when the lhs is a hash - 'for' still seems adequate and simple to me:

#!/usr/bin/perl 

use strict ;
use warnings ;

my @inp = ("abc_A_bla", "abc_B_bla", "abc_C_bla") ;

my %inp ;

$inp{ $1 } = /\w{3}_(\w)/ || next for @inp; 

foreach ( keys %inp ) {
    print "Found $_\n" ;
}
[download]