Answer

Background:

Slices are a powerful feature of Perl that allow you to extract or assign a group of elements from an array or hash in a single operation. The slice mechanism has been around since the early versions of Perl, supports a syntax similar to Python, but has its own execution and context peculiarities.

Problem:

The main difficulty with slices is to distinguish between array and hash slices, their scalar/list context, and the "subtle" nuances when assigning through a slice (especially if the assignment targets the same arrays or hashes, or if duplicate indices are used). An important point is that if you update the structure with slices, it's easy to accidentally get an unexpected result due to automatic list expansion.

Solution:

Use slices thoughtfully. When you need to make a copy of data, use explicit list cloning. Avoid overlaps in reading and writing, and pay close attention to scalar/list context if the slice is used as a function argument or an element in an expression.

Code example:

my @array = (10, 20, 30, 40, 50);
my @slice = @array[1, 3];      # (20, 40)
@array[0, 2] = (100, 300);     # @array becomes (100, 20, 300, 40, 50)

my %hash = (foo => 1, bar => 2, baz => 3);
my @vals = @hash{"foo", "baz"};  # (1, 3)

Key features:

A slice returns a list, not a reference to a sub-array/sub-hash
You can assign new values to multiple elements at once
Indices and keys can be duplicated — and the result will be non-obvious

Tricky questions

Tricky question 1: Can you take a "scalar" value from the slice @array[2, 4] as $val = @array[2, 4]?

No, $val in this case will be equal to the number of elements (the length of the list), not the value of a single element. You should access individual elements through single indices: $array[2].

Tricky question 2: If there are duplicate indices in the slice, what gets assigned?

Sequential reassignment occurs: assignments are made for each index from left to right, the last one wins. For example:

@array[0,0] = (1,2); # $array[0] == 2

Tricky question 3: Can you assign slices with differing numbers of elements on the right and left?

Yes, if there are fewer on the right, the remaining will receive undef. If there are more — the extras are ignored. This is often a source of hard-to-detect errors.

Common mistakes and anti-patterns

Assigning mixed-up slices, expecting values to replicate
Using a slice where a sub-array or array reference is needed
Violating the order/dimensionality of assigned elements

Real-life example

Negative case

A developer assigns values: @array[2, 3] = ("foo");

Expected both elements to get "foo", but $array[3] became undef.

Pros:

Quick code change

Cons:

Non-obvious behavior, broken data

Positive case

Uses the map function to map values: @array[2, 3] = map { "foo" } (2, 3);