rust-async_skill

Overview

This skill is an advanced Rust async patterns expert that guides stream processing, backpressure control, task cancellation, select/join strategies, and Future trait implementation. It focuses on practical patterns, trade-offs, and verification steps to make async code correct and performant. The guidance is concise and aimed at real-world engineering decisions and reviews.

How this skill works

The skill inspects async code and proposes concrete rewrites, concurrency strategies, and backpressure mechanisms based on the data flow and runtime constraints. It recommends when to use streams vs iterators, how to bound concurrency with semaphores or buffered streams, and how to implement cooperative cancellation and timeouts. It also flags common mistakes (forgotten .await, locks across await, unbounded concurrency) and suggests verification commands and profiling tips.

When to use it

• Processing continuous or networked data flows (websockets, pagination, file streams).
• Protecting downstream systems from overload or preventing resource exhaustion.
• Waiting on multiple async sources where first-to-complete or timeouts are required.
• Implementing custom async primitives or optimizing runtime behavior.
• Designing reviews or audits for async correctness and performance.

Best practices

• Choose Stream for async sources and Iterator for sync sources to avoid overhead.
• Limit concurrency with buffer_unordered, Semaphore, or bounded channels to enforce backpressure.
• Make cancellation cooperative: add yield points, timeout wrappers, and explicit abort signals.
• Never hold locks across .await; minimize lock scope and drop before awaiting.
• Use spawn_blocking for CPU-bound work and profile with flamegraph/tokio-console.

Example use cases

• Batch-processing websocket messages with stream.chunks() and for_each_concurrent to reduce per-item overhead.
• Implementing backpressure using a Semaphore + buffer_unordered to cap concurrent upstream work.
• Multiplexing I/O and timers with tokio::select to handle messages and periodic health checks.
• Fail-fast composition with try_join when all subtasks must succeed; use join when collecting all results despite failures.
• Implementing a custom Future for specialized wakeup semantics or low-level async primitives.