map BLOCK LIST
map EXPR,LIST
        Evaluates the BLOCK or EXPR for each element of LIST (locally
        setting $_ to each element) and returns the list value compose
+d
        of the results of each such evaluation. In scalar context,
        returns the total number of elements so generated. Evaluates
        BLOCK or EXPR in list context, so each element of LIST may
        produce zero, one, or more elements in the returned value.

            @chars = map(chr, @nums);

        translates a list of numbers to the corresponding characters.
        And

            %hash = map { getkey($_) => $_ } @array;

        is just a funny way to write

            %hash = ();
            foreach $_ (@array) {
                $hash{getkey($_)} = $_;
            }

        Note that $_ is an alias to the list value, so it can be used 
+to
        modify the elements of the LIST. While this is useful and
        supported, it can cause bizarre results if the elements of LIS
+T
        are not variables. Using a regular "foreach" loop for this
        purpose would be clearer in most cases. See also "grep" for an
        array composed of those items of the original list for which t
+he
        BLOCK or EXPR evaluates to true.

        "{" starts both hash references and blocks, so "map { ..." cou
+ld
        be either the start of map BLOCK LIST or map EXPR, LIST. Becau
+se
        perl doesn't look ahead for the closing "}" it has to take a
        guess at which its dealing with based what it finds just after
        the "{". Usually it gets it right, but if it doesn't it won't
        realize something is wrong until it gets to the "}" and
        encounters the missing (or unexpected) comma. The syntax error
        will be reported close to the "}" but you'll need to change
        something near the "{" such as using a unary "+" to give perl
        some help:

            %hash = map {  "\L$_", 1  } @array  # perl guesses EXPR.  
+wrong
            %hash = map { +"\L$_", 1  } @array  # perl guesses BLOCK. 
+right
            %hash = map { ("\L$_", 1) } @array  # this also works
            %hash = map {  lc($_), 1  } @array  # as does this.
            %hash = map +( lc($_), 1 ), @array  # this is EXPR and wor
+ks!

            %hash = map  ( lc($_), 1 ), @array  # evaluates to (1, @ar
+ray)

        or to force an anon hash constructor use "+{"

           @hashes = map +{ lc($_), 1 }, @array # EXPR, so needs , at 
+end

        and you get list of anonymous hashes each with only 1 entry.

grep BLOCK LIST
grep EXPR,LIST
        This is similar in spirit to, but not the same as, grep(1) and
        its relatives. In particular, it is not limited to using regul
+ar
        expressions.

        Evaluates the BLOCK or EXPR for each element of LIST (locally
        setting $_ to each element) and returns the list value
        consisting of those elements for which the expression evaluate
+d
        to true. In scalar context, returns the number of times the
        expression was true.

            @foo = grep(!/^#/, @bar);    # weed out comments

        or equivalently,

            @foo = grep {!/^#/} @bar;    # weed out comments

        Note that $_ is an alias to the list value, so it can be used 
+to
        modify the elements of the LIST. While this is useful and
        supported, it can cause bizarre results if the elements of LIS
+T
        are not variables. Similarly, grep returns aliases into the
        original list, much as a for loop's index variable aliases the
        list elements. That is, modifying an element of a list returne
+d
        by grep (for example, in a "foreach", "map" or another "grep")
        actually modifies the element in the original list. This is
        usually something to be avoided when writing clear code.

        See also "map" for a list composed of the results of the BLOCK
        or EXPR.
[download]