# Rust Async Patterns

> Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing concurrent systems, or debugging async code.

Source: https://skillsagentes.com/skills/wshobson/agents/rust-async-patterns
Repository: https://github.com/wshobson/agents
Author: wshobson
License: MIT
Updated: hace 2 meses
Context cost: 49 tok installed, 670 tok once triggered, 3.1k tok with every bundled file
Bundle: 2 files, 12 KB
Permissions requested: none declared

## Install

```bash
npx -y skills add wshobson/agents --skill rust-async-patterns --agent claude-code
```

## What it does

- Aporta patrones de producción para Rust asíncrono con Tokio: tareas, canales, streams y manejo de errores
- Da buenas prácticas concretas como usar tokio::select!, JoinSet, CancellationToken y semáforos
- Incluye ejemplo de arranque con Cargo.toml y main con #[tokio::main]
- Referencia patrones detallados en references/details.md para casos que la guía rápida no cubre

## Use it when

- Construir aplicaciones async en Rust
- Implementar servicios de red concurrentes
- Usar Tokio para I/O asíncrono
- Depurar u optimizar código async

## What triggers it

- "Ayúdame a estructurar un servicio async en Rust con Tokio"
- "¿Cómo evito bloqueos manteniendo locks entre awaits en Rust?"
- "Necesito manejar cancelación de tareas async con CancellationToken"
- "Cómo limitar tareas concurrentes con un semáforo en Tokio"

## Before you install

- Requiere el crate tokio con la feature "full", además de futures, async-trait, anyhow y tracing en Cargo.toml.

## Files

- SKILL.md — 3 KB
- references/details.md — 10 KB

## SKILL.md

Reproduced verbatim from wshobson/agents under MIT. This section is the upstream document and is in English.

# Rust Async Patterns

Production patterns for async Rust programming with Tokio runtime, including tasks, channels, streams, and error handling.

## When to Use This Skill

- Building async Rust applications
- Implementing concurrent network services
- Using Tokio for async I/O
- Handling async errors properly
- Debugging async code issues
- Optimizing async performance

## Core Concepts

### 1. Async Execution Model

```
Future (lazy) → poll() → Ready(value) | Pending
                ↑           ↓
              Waker ← Runtime schedules
```

### 2. Key Abstractions

| Concept    | Purpose                                  |
| ---------- | ---------------------------------------- |
| `Future`   | Lazy computation that may complete later |
| `async fn` | Function returning impl Future           |
| `await`    | Suspend until future completes           |
| `Task`     | Spawned future running concurrently      |
| `Runtime`  | Executor that polls futures              |

## Quick Start

```toml
# Cargo.toml
[dependencies]
tokio = { version = "1", features = ["full"] }
futures = "0.3"
async-trait = "0.1"
anyhow = "1.0"
tracing = "0.1"
tracing-subscriber = "0.3"
```

```rust
use tokio::time::{sleep, Duration};
use anyhow::Result;

#[tokio::main]
async fn main() -> Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt::init();

    // Async operations
    let result = fetch_data("https://api.example.com").await?;
    println!("Got: {}", result);

    Ok(())
}

async fn fetch_data(url: &str) -> Result<String> {
    // Simulated async operation
    sleep(Duration::from_millis(100)).await;
    Ok(format!("Data from {}", url))
}
```

## Detailed patterns and worked examples

Detailed pattern documentation lives in `references/details.md`. Read that file when the navigation tier above is insufficient.

## Best Practices

### Do's

- **Use `tokio::select!`** - For racing futures
- **Prefer channels** - Over shared state when possible
- **Use `JoinSet`** - For managing multiple tasks
- **Instrument with tracing** - For debugging async code
- **Handle cancellation** - Check `CancellationToken`

### Don'ts

- **Don't block** - Never use `std::thread::sleep` in async
- **Don't hold locks across awaits** - Causes deadlocks
- **Don't spawn unboundedly** - Use semaphores for limits
- **Don't ignore errors** - Propagate with `?` or log
- **Don't forget Send bounds** - For spawned futures

---

Skills Agentes — https://skillsagentes.com/skills/wshobson/agents/rust-async-patterns