Модуль prelude

Предел (prelude) конкурентности futures.

Реэкспорт

#![allow(unused)]
fn main() {
pub use super::future::FutureExt as _;
pub use super::stream::StreamExt as _;
pub use super::future::Join as _;
pub use super::future::Race as _;
pub use super::future::RaceOk as _;
pub use super::future::TryJoin as _;
pub use super::stream::Chain as _;
pub use super::stream::IntoStream as _;
pub use super::stream::Merge as _;
pub use super::stream::Zip as _;
pub use super::concurrent_stream::ConcurrentStream;
pub use super::concurrent_stream::FromConcurrentStream;
pub use super::concurrent_stream::IntoConcurrentStream;
}

Модуль prelude предоставляет удобный способ импортировать все основные трейты и типы futures-concurrency одним оператором use. Это стандартная практика в экосистеме Rust для упрощения импорта часто используемых компонентов.

Использование

Добавьте следующую строку в начало вашего файла для импорта всех основных компонентов futures-concurrency:

#![allow(unused)]
fn main() {
use futures_concurrency::prelude::*;
}

Что включается в предел

Трейты для Future

FutureExt - методы расширения для Future
Join - ожидание завершения всех future
Race - ожидание завершения первого future
RaceOk - ожидание завершения первого успешного future
TryJoin - ожидание успешного завершения всех future или досрочное прерывание при ошибке

Трейты для Stream

StreamExt - методы расширения для Stream
Chain - объединение потоков
IntoStream - преобразование в поток
Merge - слияние потоков
Zip - объединение потоков в пары

Трейты для конкурентных потоков

ConcurrentStream - конкурентная работа с элементами в потоке
FromConcurrentStream - преобразование из конкурентного потока
IntoConcurrentStream - преобразование в конкурентный поток

Примеры использования

Базовое использование

use futures_concurrency::prelude::*;
use std::future;

#[tokio::main]
async fn main() {
    // Использование методов из FutureExt
    let a = future::ready(1);
    let b = future::ready(2);
    
    // Метод join() доступен благодаря импорту трейта Join
    let result = (a, b).join().await;
    assert_eq!(result, (1, 2));
}

Работа с потоками

use futures_concurrency::prelude::*;
use tokio_stream::{self as stream, StreamExt};

#[tokio::main]
async fn main() {
    let stream1 = stream::iter(vec![1, 2]);
    let stream2 = stream::iter(vec![3, 4]);
    
    // Метод merge() доступен благодаря импорту трейта Merge
    let merged = (stream1, stream2).merge();
    
    let results: Vec<_> = merged.collect().await;
    // Порядок элементов может варьироваться из-за природы merge
    assert!(results.contains(&1) && results.contains(&4));
}

Конкурентные потоки

use futures_concurrency::prelude::*;

#[tokio::main]
async fn main() {
    let items = vec!["hello", "world"];
    
    // Преобразование в конкурентный поток
    let results: Vec<String> = items
        .into_co_stream()  // Доступно благодаря IntoConcurrentStream
        .map(|s| async move { s.to_uppercase() })
        .collect()         // Доступно благодаря ConcurrentStream
        .await;
    
    assert_eq!(results, vec!["HELLO", "WORLD"]);
}

Преимущества использования prelude

Удобство: Один импорт вместо множества отдельных
Согласованность: Стандартизированный способ импорта
Полнота: Все основные компоненты доступны сразу
Обновляемость: Новые функции автоматически включаются в предел

Примечание

Импорт с as _ означает, что трейты импортируются только для их побочных эффектов (добавления методов к существующим типам), но сами имена трейтов не добавляются в область видимости. Это предотвращает конфликты имен.

Например, после use futures_concurrency::prelude::*; вы можете использовать методы типа join() на кортежах future, но не можете напрямую ссылаться на тип Join.

DOCS.RS