Answer.

Background:

From the very beginning of its development, Perl has paid great attention to working with arrays and lists of data. Functions like map, grep, and the foreach loop operator allow programmers to succinctly and efficiently process collections, implementing powerful functional programming patterns in a single expression.

Problem:

Many novice Perl programmers confuse when to use map, foreach, or grep, which leads to the wrong choice of tool and reduces performance or readability of the code. Additionally, inattentiveness to side effects in the bodies of such expressions can lead to hard-to-debug errors.

Solution:

The correct choice of data traversal tool depends on the task:

map — used for transforming elements of a list and constructing a new result list.
grep — filters the elements of the source list based on a given condition.
foreach — used for side effects and iterative processing, often without a return value.

Example code:

my @numbers = (1, 2, 3, 4, 5);
my @squares = map { $_ * $_ } @numbers;                # [1, 4, 9, 16, 25]
my @even = grep { $_ % 2 == 0 } @numbers;              # [2, 4]
foreach my $n (@numbers) {
    print "Number: $n
";                              # prints each element
}

Key features:

map and grep operate in list context and return a new list.
foreach does not create a new list but simply iterates over the elements.
Side effects in the body of map or grep are not recommended.

Tricky Questions.

Is it safe to modify an array within the body of map or grep?

No, because Perl iterates over copies of the elements, but modifying the original array could lead to unexpected results or even an infinite loop.

What happens if you use return in the body of map or grep?

The return expression within an anonymous block will exit the surrounding subroutine, not just the body of the map/grep, which is dangerous for program logic.

Example code:

sub example {
    my @data = (1, 2, 0, 4);
    my @result = map { return "oops" if $_ == 0; $_+1 } @data; # exits example on 0
}

Why shouldn't you use map just for side effects?

Because map is intended for generating new lists, and all its elements are computed immediately. For side effects, it’s more optimal to use foreach — it’s more readable and doesn’t require storing the result.

Common Mistakes and Anti-Patterns

Using map or grep solely for side effects.
Modifying the structure of the original data within map or grep.
Incorrect handling of return inside the block.

Real-Life Example

Negative Case

In the project, map was used for logging, without caring for the returned list.

Pros:

Brief and "functional" code.

Cons:

Excessive memory consumption.
No sense in the returned values, making the code harder to understand.

Positive Case

Used foreach for logging and map only for generating new lists, without mixing patterns.