git:20260729.f16bff5 to git:20260816.d23736e

---

name: rust-programming-expert

description: "Expert-level skill for Rust programming (Rust 2024 / v1.85+). Covers memory safety, async, Axum/SQLx, CLI, and optimization in English and Indonesian."

---

# Rust Programming Expert (2024 Edition / v1.88+)

[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)

---

<a name="english"></a>

## English

### Description

Expert-level Rust development for building memory-safe, high-performance systems, APIs, CLI tools, and WebAssembly. Covers the **Rust 2024 edition**, async/await with Tokio, Axum 0.8 web framework, SQLx for async database access, and modern Rust idioms.

### Trigger Conditions

- Writing systems-level code requiring memory safety and zero-cost abstractions.

- Building high-performance HTTP APIs with **Axum 0.8**.

- Implementing async services with **Tokio** runtime.

- Interacting with databases using **SQLx** or **SeaORM**.

- Building CLI tools with **Clap v4**.

- Compiling to **WebAssembly (WASM)** for browser or edge deployment.

- Writing Rust for **Tauri v2** desktop application backends.

### Rust 2024 Edition Highlights

The Rust 2024 edition (stabilized in 1.85) introduces:

- **`gen` blocks**: Generators for lazy sequence production.

- **Lifetime capture rules**: More precise lifetime inference in `impl Trait`.

- **Unsafe extern blocks**: Clearer unsafe boundary declarations.

- **`if let` chains**: `if let Some(x) = opt && x > 0` now works cleanly.

- **`async fn` in traits**: Now stable — no more `async-trait` macro needed.

### Async `fn` in Traits (Stable in Rust 2024)

```rust

// No longer need #[async_trait] macro!

trait DataStore {

async fn get(&self, id: &str) -> Result<Data, Error>;

async fn set(&self, id: &str, data: Data) -> Result<(), Error>;

}

impl DataStore for PostgresStore {

async fn get(&self, id: &str) -> Result<Data, Error> {

sqlx::query_as("SELECT * FROM data WHERE id = $1")

.bind(id)

.fetch_one(&self.pool)

.await

.map_err(Into::into)

}

async fn set(&self, id: &str, data: Data) -> Result<(), Error> {

sqlx::query("INSERT INTO data (id, value) VALUES ($1, $2) ON CONFLICT (id) DO UPDATE SET value = $2")

.bind(id)

.bind(&data.value)

.execute(&self.pool)

.await?;

Ok(())

}

}

```

### Axum 0.8 — HTTP API Framework

```rust

use axum::{

extract::{Path, State},

response::Json,

routing::{get, post},

Router,

};

use sqlx::PgPool;

use serde::{Deserialize, Serialize};

#[derive(Clone)]

struct AppState {

db: PgPool,

}

#[derive(Serialize, Deserialize)]

struct User {

id: String,

name: String,

email: String,

}

async fn get_user(

Path(user_id): Path<String>,

State(state): State<AppState>,

) -> Result<Json<User>, StatusCode> {

let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", user_id)

.fetch_optional(&state.db)

.await

.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?

.ok_or(StatusCode::NOT_FOUND)?;

Ok(Json(user))

}

#[tokio::main]

async fn main() {

let db = PgPool::connect(&std::env::var("DATABASE_URL").unwrap())

.await

.expect("Failed to connect to database");

let state = AppState { db };

let app = Router::new()

.route("/users/:id", get(get_user))

.route("/users", post(create_user))

.with_state(state);

let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();

println!("Listening on :8080");

axum::serve(listener, app).await.unwrap();

}

```

### SQLx — Compile-Time Verified SQL

```rust

// Compile-time SQL checking (requires DATABASE_URL at build time)

let users = sqlx::query_as!(

User,

r#"SELECT id, name, email FROM users WHERE created_at > $1 ORDER BY created_at DESC LIMIT $2"#,

since,

limit as i64

)

.fetch_all(&pool)

.await?;

```

### Error Handling — thiserror + anyhow

```rust

use thiserror::Error;

// Library errors: use thiserror for typed errors

#[derive(Debug, Error)]

pub enum AppError {

#[error("User not found: {id}")]

UserNotFound { id: String },

#[error("Database error: {0}")]

Database(#[from] sqlx::Error),

#[error("Validation failed: {message}")]

Validation { message: String },

}

// Application code: use anyhow for ergonomic error propagation

use anyhow::{Context, Result};

fn process() -> Result<()> {

let config = load_config().context("Failed to load configuration")?;

let db = connect_db(&config).context("Failed to connect to database")?;

Ok(())

}

```

### CLI Tools with Clap v4

```rust

use clap::{Parser, Subcommand};

#[derive(Parser)]

#[command(name = "myapp", version, about = "My CLI tool")]

struct Cli {

#[command(subcommand)]

command: Commands,

}

#[derive(Subcommand)]

enum Commands {

/// Start the server

Serve {

#[arg(short, long, default_value = "8080")]

port: u16,

},

/// Run migrations

Migrate,

}

#[tokio::main]

async fn main() -> anyhow::Result<()> {

let cli = Cli::parse();

match cli.command {

Commands::Serve { port } => serve(port).await,

Commands::Migrate => run_migrations().await,

}

}

```

### Performance Best Practices

- **Zero-cost abstractions**: Use iterators (`map`, `filter`, `collect`) — compiled to the same code as hand-written loops.

- **Avoid unnecessary cloning**: Use references (`&T`) and lifetimes where possible.

- **`Arc<T>` for shared state**: Use `Arc<Mutex<T>>` or `Arc<RwLock<T>>` for shared mutable state across threads.

- **SIMD**: Use `std::simd` (stable in 1.88) for data-parallel operations.

- **Profile before optimizing**: Use `cargo flamegraph` or `perf` to find actual bottlenecks.

---

<a name="bahasa-indonesia"></a>

## Bahasa Indonesia

### Deskripsi

Pengembangan Rust tingkat ahli untuk membangun sistem, API, CLI tool, dan WebAssembly yang aman di memori dan berkinerja tinggi. Mencakup **edisi Rust 2024**, async/await dengan Tokio, framework web Axum 0.8, SQLx untuk akses database async, dan idiom Rust modern.

### Kondisi Pemicu

- Menulis kode sistem yang membutuhkan keamanan memori dan zero-cost abstraction.

- Membangun HTTP API berkinerja tinggi dengan **Axum 0.8**.

- Mengimplementasikan layanan async dengan runtime **Tokio**.

- Berinteraksi dengan database menggunakan **SQLx** atau SeaORM.

- Membangun CLI tool dengan **Clap v4**.

- Mengkompilasi ke **WebAssembly (WASM)** untuk browser atau edge.

- Menulis backend Rust untuk aplikasi desktop **Tauri v2**.

### Sorotan Edisi Rust 2024

- **`async fn` dalam trait**: Kini stabil — tidak perlu lagi macro `#[async_trait]`.

- **`if let` chains**: `if let Some(x) = opt && x > 0` kini berfungsi secara bersih.

- **`gen` blocks**: Generator untuk produksi urutan yang malas.

- **Aturan lifetime capture**: Inferensi lifetime yang lebih presisi di `impl Trait`.

### Axum 0.8 — Framework HTTP API

Gunakan Axum untuk HTTP API yang idiomatis dan berkinerja tinggi dibangun di atas Tokio. Manfaatkan extractor (`Path`, `State`, `Json`, `Query`) untuk parameter handler yang type-safe.

### SQLx — SQL Terverifikasi Waktu Kompilasi

SQLx memverifikasi query SQL Anda terhadap database nyata saat kompilasi — menghilangkan seluruh kelas bug runtime.

### Penanganan Error — thiserror + anyhow

- Gunakan `thiserror` untuk error bertipe di library code.

- Gunakan `anyhow` untuk propagasi error yang ergonomis di application code.

### CLI Tool dengan Clap v4

Clap v4 menggunakan derive macro untuk mendefinisikan antarmuka CLI secara deklaratif — perintah, subperintah, argumen, dan flag dengan parsing bawaan.

### Praktik Terbaik Performa

- Gunakan iterator (`map`, `filter`, `collect`) — dikompilasi setara dengan loop manual.

- Hindari cloning yang tidak perlu — gunakan referensi dan lifetime.

- Gunakan `Arc<Mutex<T>>` untuk state bersama yang dapat dimutasi di antara thread.

- Profiling terlebih dahulu dengan `cargo flamegraph` sebelum mengoptimalkan.