In-place Mutation vs Functional Transformation

In this lesson, you will learn how to evaluate whether to perform in-place mutation or functional transformation based on performance constraints and memory overhead.

As you have explored heap allocation strategies and memory layout, you know that Vec and other collections occupy contiguous memory. When you use a functional pipeline—like my_vec.into_iter().map(transform).collect()—you are often allocating a fresh collection. While this pattern is idiomatic, expressive, and minimizes side effects, it forces the allocator to find new space and move data, incurring a performance cost proportional to the collection size.

When to Prefer Mutation

In-place mutation (e.g., using for item in &mut my_vec { *item = transform(item); }) is almost always more efficient when:

1. Size is Constant: You aren't adding or removing elements; you are simply updating the data already present.
2. Memory is Limited: Reallocating forces the system to hold both the old and new collections in memory simultaneously, potentially doubling your peak heap usage.
3. Locality of Reference: By updating in-place, you maintain the same cache lines and keep memory operations strictly within the existing buffer, which is friendlier to the CPU’s prefetcher.

When to Prefer Transformation

Functional pipelines are superior when:

1. Filtering: If you need to drop elements, retain is your in-place mutation tool, but if the filtering logic is complex or results in a drastically different data shape, a filter pipeline is safer and more readable.
2. Parallelization: Pipelines integrate seamlessly with rayon. Transformation logic can be parallelized trivially, whereas in-place mutation often requires careful synchronization if parts of the collection depend on other indices.
3. Ownership Chains: If you need to consume an existing structure to create a new one, a pipeline is the natural architectural choice.

Consider an image processing buffer. If you are applying a simple brightness adjustment, for pixel in &mut pixels { *pixel += 10; } is optimal. If you are applying a complex convolution kernel that requires reading neighboring pixels to create a new pixel, the safety and clarity of a functional approach far outweigh the small cost of a secondary allocation.

Key Takeaway: Choose in-place mutation to minimize heap churn and maximize cache efficiency when updating values; choose functional transformations for complex data derivation and thread-parallel workflows.