rust-programming-expert

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." author: "Roedy Rustam"

Rust Programming Expert

English | Bahasa Indonesia

English

Description

Expert-level guidance for writing high-performance, robust, and memory-safe systems applications using Rust 2024 (v1.85+). This skill outlines advanced practices in ownership, lifetimes, error design, async architectures, backend development, performance tuning, and idiomatic ecosystem patterns.

Trigger Conditions

• Use when bootstrapping or maintaining a production Rust crate, application, or workspace.
• Use when designing data models involving complex lifetimes, smart pointers (Arc, Rc, RefCell), or zero-copy abstractions (Cow).
• Use when building high-concurrency async services with Tokio and Axum.
• Use when interacting with databases safely using compile-time checked SQL with SQLx.
• Use when crafting modern CLI utilities using Clap and Serde.
• Use when migrating or upgrading an existing Rust codebase to the Rust 2024 Edition.
• Use when profiling, optimizing, or debugging compile times, memory footprints, or runtime performance.

Rust 2024 Edition & Core Architecture

Rust 2024 (stabilized in Rust v1.85) enhances language ergonomics, strengthens safety invariants, and introduces native async enhancements:

• Async Closures: Stable async || {} & AsyncFn traits.
• RPIT Lifetimes: RPIT (impl Trait in return position) captures all in-scope lifetimes by default. Use explicit use<'a, T> syntax if you want to restrict lifetime capturing.
• Unsafe Extern: extern blocks and specific attributes (no_mangle) now require the unsafe keyword.
• Prelude Additions: Future and IntoFuture are now imported automatically.

Language Essentials & Memory Safety

Memory safety in Rust is guaranteed at compile time through the ownership system:

1. Ownership & Borrowing: Each value has a single owner. You can have any number of immutable references (&T) OR exactly one active mutable reference (&mut T) to a value at any given time.
2. Lifetimes & Smart Pointers: Avoid references (&T) in struct definitions unless short-lived. Use Arc<T> and Mutex<T> or RwLock<T> for thread-safe state sharing.

Idiomatic Error Handling

Rust utilizes the Result<T, E> and Option<T> monads:

• Application-level Errors: Use anyhow for high-level application contexts where stack traces and arbitrary error wrapping are needed.
• Library-level Errors: Use thiserror to define precise, structured, and descriptive domain error enums.

Asynchronous Programming (Rust 2024 + Tokio)

• Prefer Tokio Tasks for I/O: Use tokio::spawn to run light, concurrent tasks that perform asynchronous I/O.
• Do NOT Block the Async Runtime: Never run CPU-bound work or synchronous block-I/O directly inside an async worker thread. Use tokio::task::spawn_blocking to offload heavy calculations.

Production Ecosystem Integrations

• Axum + SQLx: High performance async routing combined with compile-time checked PostgreSQL database queries.
• Clap + Serde: Declarative command-line argument parser and serialization/deserialization.

Optimization & Unsafe Code

• Avoid Heap Allocations: Use slices &[T] and zero-copy Cow<'a, str> wrappers where possible.
• Release Profile (Cargo.toml): Use opt-level = 3, lto = true, and codegen-units = 1 for production.
• Sound Unsafe: Only use unsafe when absolutely required. Always document with a // SAFETY: block.

Troubleshooting & Common Gotchas / Pemecahan Masalah

• Lifetimes Mismatch: Ensure returned references don't point to local variables. Use owned types or bind output lifetimes to input lifetimes.
• Send / Sync Boundary Failures: Async block elements across .await must implement Send. Avoid holding synchronous mutex guards across .await points.

Bahasa Indonesia

Deskripsi

Panduan tingkat ahli untuk menulis aplikasi sistem yang berkinerja tinggi, tangguh, dan aman secara memori menggunakan Rust 2024 (v1.85+). Skill ini menguraikan praktik-praktik lanjutan dalam kepemilikan (ownership), masa hidup (lifetimes), desain error, arsitektur asinkron, pengembangan backend, optimasi performa, dan pola ekosistem yang idiomatis.

Kondisi Pemicu

• Gunakan saat merancang atau memelihara crate, aplikasi, atau workspace Rust tingkat produksi.
• Gunakan saat mendesain model data dengan lifetime yang kompleks, smart pointers (Arc, Rc, RefCell), atau abstraksi zero-copy (Cow).
• Gunakan saat membangun layanan asinkron konkurensi tinggi dengan Tokio dan Axum.
• Gunakan saat berinteraksi dengan database secara aman menggunakan SQL yang diverifikasi saat kompilasi dengan SQLx.
• Gunakan saat merancang utilitas CLI modern menggunakan Clap dan Serde.
• Gunakan saat memigrasikan atau meningkatkan codebase Rust yang ada ke Edisi Rust 2024.
• Gunakan saat melakukan profiling, mengoptimalkan, atau men-debug waktu kompilasi, penggunaan memori, atau kinerja runtime.

Edisi Rust 2024 & Arsitektur Inti

Edisi Rust 2024 meningkatkan ergonomi bahasa, memperkuat invariant keamanan, dan memperkenalkan peningkatan asinkron bawaan:

• Async Closures: Traits AsyncFn dan penulisan closure async || {} sekarang stabil. Gunakan untuk adapter stream asinkron atau event handler langsung.
• RPIT Lifetimes: RPIT (impl Trait pada posisi return) menangkap semua lifetime dalam scope secara default. Gunakan sintaksis eksplisit use<'a, T> untuk membatasi penangkapan lifetime.
• Unsafe Extern: Blok extern dan atribut tertentu (no_mangle) sekarang memerlukan kata kunci unsafe.
• Tambahan Prelude: Future dan IntoFuture sekarang diimpor secara otomatis.

Dasar Bahasa & Keamanan Memori

Keamanan memori dijamin saat kompilasi melalui sistem kepemilikan (ownership). Ikuti panduan berikut:

1. Kepemilikan & Peminjaman: Setiap nilai memiliki satu pemilik. Ketika pemilik keluar dari scope, nilai tersebut dihapus. Anda dapat memiliki banyak referensi immutable (&T) ATAU tepat satu referensi mutable (&mut T) aktif pada satu waktu.
2. Lifetimes & Smart Pointers: Hindari meletakkan referensi (&T) di dalam definisi struct kecuali untuk struct pembantu berumur pendek. Gunakan Arc<T> (Thread-Safe Shared Reference) dan Mutex<T> (Mutual Exclusion) untuk berbagi state antar thread.

Penanganan Error yang Idiomatis

Rust menggunakan monad Result<T, E> and Option<T> alih-alih exception tradisional.

• Tingkat Aplikasi: Gunakan anyhow untuk pembuatan skrip cepat atau konteks aplikasi tingkat tinggi di mana pelacakan stack dan pembungkusan error acak diperlukan.
• Tingkat Library: Gunakan thiserror untuk mendefinisikan enum error domain yang tepat, terstruktur, dan deskriptif.

Pemrograman Asinkron (Rust 2024 + Tokio)

• Gunakan Tugas Tokio untuk I/O: Gunakan tokio::spawn untuk menjalankan tugas-tugas ringan dan konkuren.
• JANGAN Blokir Runtime Asinkron: Jangan pernah menjalankan pekerjaan berat CPU atau I/O sinkron secara langsung di dalam thread pekerja asinkron. Gunakan tokio::task::spawn_blocking jika diperlukan.

Integrasi Ekosistem Produksi

• Axum + SQLx (Web API Stack): Axum menyediakan framework web asinkron terkemuka, sementara SQLx menyediakan lapisan interaksi database dengan pemeriksaan keamanan SQL pada saat kompilasi.
• Clap + Serde (CLI Stack): Clap v4 menyediakan parser argumen baris perintah deklaratif berbasis makro. Serde menangani serialisasi/deserialisasi dengan lancar.

Optimasi & Kode Unsafe

• Hindari Alokasi Heap: Gunakan &str alih-alih String untuk variabel read-only. Gunakan Cow<'a, str> ketika variabel hanya sesekali dimutasi.
• Konfigurasi Profil Release (Cargo.toml): Gunakan opt-level = 3, lto = true, dan codegen-units = 1 untuk kinerja maksimal.
• Kode Unsafe yang Aman: Hanya gunakan unsafe untuk memanggil binding C atau struktur data lockless kustom. Selalu sertakan blok // SAFETY: untuk menjelaskan validitas invariant.