Идиоматичное копирование/клонирование вектора в параметризованной функции на Rust

Проблема: почему компилятор требует Clone?

Вы столкнулись с фундаментальной особенностью Rust: системой владения. Когда вы пишете обобщённую функцию fn duplicate_vector<T>(vec: Vec<T>) -> Vec<T>, компилятор ничего не знает о типе T. Для копирования данных (например, через clone()) тип должен реализовывать трейт Clone. Без этого ограничения Rust не может гарантировать, что операция копирования возможна — ведь для некоторых типов (например, String или пользовательских структур с динамической памятью) простое побитовое копирование приведёт к двойному освобождению ресурсов.

Идиоматичное решение: ограничение трейтом Clone

Самый простой и правильный путь — добавить ограничение Clone к параметру типа:

fn duplicate_vector<T: Clone>(vec: &[T]) -> Vec<T> {
    vec.to_vec()
}

// Или если нужно владеть вектором:
fn duplicate_vector_owned<T: Clone>(vec: Vec<T>) -> Vec<T> {
    vec.clone()
}

Почему это идиоматично?

• Явность: вызывающий код сразу видит, что для работы функции требуется Clone.
• Безопасность: вы не сможете случайно скопировать тип, который этого не поддерживает.
• Производительность: компилятор может оптимизировать копирование для типов, которые реализуют Copy (например, i32, bool).

Альтернативы без Clone (когда Clone не нужен)

Если вы не хотите требовать Clone, есть два основных подхода:

1. Перемещение (move) вместо копирования

Если исходный вектор больше не нужен, просто переместите его:

fn process_vector<T>(vec: Vec<T>) -> Vec<T> {
    // Вектор уже принадлежит функции, можно изменять без копирования
    let mut v = vec; // перемещение
    v.push(/* ... */);
    v
}

Это работает для любого типа T без ограничений.

2. Использование замыканий для кастомизации копирования

Передайте функцию-клонировщик как параметр:

fn duplicate_with<T, F>(vec: &[T], cloner: F) -> Vec<T>
where
    F: Fn(&T) -> T,
{
    vec.iter().map(cloner).collect()
}

// Пример использования:
let original = vec![1, 2, 3];
let cloned = duplicate_with(&original, |x| *x); // для Copy-типов
let cloned_strings = duplicate_with(&vec!["a".to_string()], |s| s.clone()); // для Clone

Этот паттерн даёт максимальную гибкость, но усложняет API.

Практический совет: когда что использовать?

• Если ваш тип гарантированно реализует Clone (например, примитивы, String, Vec) — используйте vec.clone().
• Если функция должна работать с любыми типами — используйте перемещение (fn foo(vec: Vec<T>)).
• Если нужно частичное копирование — передавайте замыкание.
• Для больших структур данных — рассмотрите Rc<T> или Arc<T>, если копирование дорого.

В Rust нет «магического» способа копировать данные без ограничений — это часть философии языка: явность и безопасность важнее удобства. Добавление Clone к обобщённой функции — это нормальная практика, и её не стоит избегать.

fn duplicate_copy<T: Copy>(vec: &[T]) -> Vec<T> {
    vec.to_vec() // работает, т.к. T: Copy
}

fn process_slice<T>(slice: &[T]) -> Vec<&T> {
    slice.iter().collect()
}