Краткий ответ

Используйте стирание типа: преобразуйте futures к типу Pin<Box<dyn Future<Output = T> + Send>> либо к эквивалентному типу без Send, если задача не покидает текущий поток. Это позволяет хранить futures разных конкретных типов в одном контейнере, потому что контейнер работает через общий объект трейта и динамическую диспетчеризацию.

Исторический контекст

Каждый async-блок и каждая async fn обычно создают собственный анонимный тип future. Такой статический тип позволяет компилятору оптимизировать выполнение без виртуальных вызовов, но разные futures нельзя напрямую поместить в один Vec, поскольку элементы вектора должны иметь один тип.

Стирание типа появилось как практический компромисс между эффективностью статической диспетчеризации и необходимостью хранить неоднородные задачи, например обработчики событий или набор операций, выбранных во время выполнения.

Постановка проблемы

Две async-задачи могут возвращать одинаковый Output, но иметь разные типы future. Это происходит даже для двух визуально одинаковых async-блоков: каждый из них компилируется в отдельный анонимный тип.

Если попытаться сохранить такие значения без стирания типа, компилятор потребует один конкретный тип элемента контейнера. Неправильное решение — заменять futures результатами их выполнения: это устранит неоднородность, но уже не позволит планировать и выполнять сами операции как задачи.

Подробное решение

Обычно применяют Box для размещения future в куче и dyn Future для стирания её конкретного типа. Pin нужен потому, что future может содержать самоссылочные состояния, а исполнитель опрашивает её через закреплённое в памяти значение.

Минимальный пример:

use std::{future::Future, pin::Pin};

type Task = Pin<Box<dyn Future<Output = ()> + Send>>;

fn erase<F>(future: F) -> Task
where
    F: Future<Output = ()> + Send + 'static,
{
    Box::pin(future)
}

let tasks: Vec<Task> = vec![
    erase(async { println!("первая") }),
    erase(async { println!("вторая") }),
];

dyn Future задаёт общий интерфейс, а Box обеспечивает единый размер элемента контейнера. При вызове poll используется динамическая диспетчеризация, поэтому такой вариант обычно немного дороже статического: появляются косвенный вызов и дополнительное размещение в куче.

Ограничение Send требуется, если future может быть передана между потоками, например многопоточным async runtime. Ограничение 'static означает, что future не содержит заимствований с более коротким временем жизни; оно типично для задач, которыми runtime владеет независимо от вызывающего кода.

Если набор вариантов известен заранее и невелик, вместо trait object можно использовать enum. Это сохраняет статическую диспетчеризацию и часто уменьшает накладные расходы, но требует заранее описать все варианты. Если типы и состав задач выбираются динамически, Pin<Box<dyn Future<...>>> обычно проще.

Ситуация из практики

Сервис собирает обработчики нескольких типов событий в один список. Каждый обработчик возвращает future собственного типа, поэтому прямой Vec невозможен.

Вариант с отдельным контейнером для каждого типа сохраняет максимальную производительность, но усложняет общий цикл запуска и плохо масштабируется при добавлении обработчиков. enum устраняет динамическую диспетчеризацию, однако требует изменять перечисление при каждом новом обработчике.

Выбран Vec<Pin<Box<dyn Future<Output = Result<(), Error>> + Send>>: обработчики можно регистрировать динамически, а runtime получает единообразные задачи. Компромисс — небольшие расходы на выделение памяти и виртуальный вызов; для сетевого сервиса они обычно менее значимы, чем стоимость самого ввода-вывода.

Что кандидаты часто упускают

1. Вопрос: Достаточно ли заменить dyn Future на Box<dyn Future>?

Ответ: Нет. Box решает проблему размера trait object, но future всё ещё должна опрашиваться через Pin<&mut Self>. Поэтому для общего хранения обычно используют Pin<Box<dyn Future<...>>>. Получить такой тип удобно через Box::pin.

2. Вопрос: Всегда ли для стирания типа future требуется ограничение Send?

Ответ: Нет. Send нужен только при возможности передачи future между потоками. Для однопоточного runtime или локального контейнера допустим тип Pin<Box<dyn Future<Output = T>>>. Добавление Send без необходимости сужает множество допустимых futures, например исключает futures, содержащие несинхронные значения вроде Rc.

3. Вопрос: Почему ограничение 'static не означает, что future обязательно живёт вечно?

Ответ: 'static описывает допустимые заимствования внутри future, а не фактическую продолжительность её существования. Future с этим ограничением может быть уничтожена сразу после создания. Требование означает, что она не заимствует данные, которые гарантированно исчезнут раньше самой future; это делает безопасной передачу владения runtime.