rust-lang/futures-rs

Features

• Async Runtime Foundations - The core library providing Future, Stream, and Sink traits with combinators for zero-cost async programming in Rust.
• Future, Stream, and Sink Abstractions - Defines the Future, Stream, and Sink traits as core abstractions for composing asynchronous workflows.
• Async Programming - Writing asynchronous code using Rust's async/await syntax with the Future trait and executor integration.
• Async Pin Projections - Applies pin projections and stack pinning via macros to safely work with self-referential data structures.
• Stream Processing - Handles sequences of values over time with the Stream trait and its combinators.
• Async Sink Trait Implementations - Sends a sequence of values to a destination using the Sink trait and its adapters.
• Concurrent Task Execution - Spawning and driving multiple futures on executors, including thread pools and thread-local executors.
• Synchronous Context Spawning - Spawns a future on an executor from synchronous code or poll functions using trait methods.
• Future Polling Strategies - Drives futures by repeatedly polling them, registering interest in events, and waking tasks when readiness changes.
• Async-Await Flow Control - Writes asynchronous code using the native async/await notation that integrates with the Future trait.
• Async I/O Traits - Reading from and writing to I/O sources without blocking using core asynchronous I/O traits.
• Stream Combinators - Handling sequences of asynchronous values over time using the Stream trait and its combinators.
• Trait Definitions - Defines the Stream trait and combinators for composing and transforming sequences of asynchronous values.
• Async Channel Endpoints - Exchanges data between concurrent tasks using channels whose endpoints implement Future, Stream, or Sink.
• Ecosystem Interoperability - Interoperates between the 0.1 and 0.3 futures ecosystems to enable gradual migration and mixed usage of both versions.
• Async Test Harness Utilities - Includes mock contexts, pinning macros, and assertion helpers for testing asynchronous code and stream behavior.
• Future-Based Concurrency Frameworks - Joins multiple futures into a single output or selects the first one to complete among them.
• Futures API Bridges - Bridge traits and converters that enable interoperability between the legacy futures 0.1 and modern 0.3 ecosystems.
• Asynchronous Task Executors - Executes asynchronous tasks using a thread pool or a thread-local executor.
• Async Context Spawning - Spawns a future to completion from inside async functions, closures, or blocks using a macro.
• Async Task Spawning - Offers executor traits and macros for spawning and driving futures to completion in various runtime contexts.
• Executor-Agnostic Spawning - Spawns futures on executors from both async and synchronous contexts through trait methods and macros.
• Future Drivers - Drives a set of futures by polling them, waiting for I/O events, and waking tasks when their file descriptors become ready.
• Async Stream Trait Definitions - Defines the Stream trait and combinators for processing sequences of asynchronous values.
• Async Pending Emulations - Wraps a future to return Poll::Pending on its first poll and immediately wake the task, simulating a realistic async operation.
• Async Stream Assertions - Polls a stream step by step and verifies its output matches expected values, ensuring correct stream implementation.
• Try Operator Integrations - Applies the question mark operator directly to poll values, simplifying error handling in future and stream implementations.
• No-Std Environment Adapters - Operates in bare-metal environments by disabling default features and using only the core API surface.
• Futures Version Migration Layers - Provides conversion layers between futures 0.1 and 0.3 APIs, enabling gradual migration and mixed usage.
• Async Test Executors - Spawns a dedicated executor on a background thread to drive a future to completion without blocking the test.
• Async IO Trait Converters - Translates between futures 0.3 and tokio-io AsyncRead and AsyncWrite traits using dedicated combinators.
• Executor Trait Bridges - Converts between the futures 0.1 Executor trait and the futures 0.3 Spawn trait to spawn tasks across different API versions.
• Legacy Executor Runners - Converts a standard future into a futures 0.1 future so it can execute on executors built for the older version.
• Legacy Future Adapters - Converts a futures 0.1 future into a standard future so it can be used inside async functions.
• Async Task Contexts - Provides a task::Context with configurable behavior for wake and spawn operations, enabling precise inspection of future polling.
• Asynchronous Programming - Zero-cost abstractions for asynchronous programming.
• Developer Tools - Zero-cost abstractions for asynchronous programming.

Star history