Rust 2026: Traits, Generics, dan Pertanyaan Wawancara Tingkat Lanjut

Traits dan generics merupakan fondasi dari setiap program Rust yang tidak trivial. Dengan hadirnya Rust 2024 Edition (stabil sejak Rust 1.85) beserta rilis lanjutan hingga versi 1.86+, sistem trait memperoleh kemampuan baru yang signifikan: trait object upcasting, async closure melalui trait AsyncFn, serta aturan lifetime capture yang disempurnakan untuk impl Trait dalam trait. Panduan ini membahas setiap fitur tersebut secara mendetail dengan contoh kode yang dapat dikompilasi, kemudian ditutup dengan pertanyaan wawancara tingkat lanjut yang benar-benar diujikan oleh tim perekrut di tahun 2026.

Dasar-Dasar Trait yang Masih Menjebak Developer Berpengalaman

Trait mendefinisikan perilaku yang dapat dibagikan antar tipe. Generics memungkinkan fungsi dan tipe bekerja lintas berbagai tipe konkret. Keduanya menggantikan polimorfisme berbasis inheritance dengan pendekatan komposisi. Compiler melakukan monomorphization pada kode generik saat kompilasi, menghasilkan abstraksi tanpa biaya runtime (zero-cost abstractions).

Salah satu poin yang kerap menjadi batu sandungan dalam wawancara adalah perbedaan antara static dispatch (impl Trait / generics) dan dynamic dispatch (dyn Trait). Static dispatch meng-inline implementasi konkret secara langsung. Dynamic dispatch melewati vtable, menambahkan satu indirection pointer per pemanggilan.

// Static dispatch: monomorphized at compile time
fn print_static(item: &impl std::fmt::Display) {
    println!("{item}");
}

// Dynamic dispatch: vtable lookup at runtime
fn print_dynamic(item: &dyn std::fmt::Display) {
    println!("{item}");
}

Static dispatch menghasilkan kode yang lebih cepat karena compiler dapat meng-inline dan mengoptimasi setiap salinan yang telah di-monomorphize. Dynamic dispatch lebih unggul ketika tipe konkret tidak diketahui saat kompilasi, misalnya pada sistem plugin atau koleksi heterogen yang menyimpan berbagai tipe dalam satu wadah.

Trait Object Upcasting Sejak Rust 1.86

Sebelum Rust 1.86, mengonversi &dyn Child menjadi &dyn Parent memerlukan method manual as_parent() pada trait bersangkutan. Trait upcasting menghilangkan boilerplate tersebut sepenuhnya. Compiler kini menangani pertukaran vtable secara transparan untuk &, &mut, Box, Rc, dan Arc.

use std::any::Any;
use std::fmt::Debug;

trait Describable: Debug + Any {
    fn describe(&self) -> String;
}

#[derive(Debug)]
struct Sensor {
    name: String,
    value: f64,
}

impl Describable for Sensor {
    fn describe(&self) -> String {
        format!("{}: {:.2}", self.name, self.value)
    }
}

fn downcast_example(item: &dyn Describable) {
    // Upcast to &dyn Any — works since Rust 1.86
    let any_ref: &dyn Any = item;
    if let Some(sensor) = any_ref.downcast_ref::<Sensor>() {
        println!("Sensor detected: {}", sensor.name);
    }
}

Trait Describable memiliki Any sebagai supertrait. Sebelum versi 1.86, pemanggilan downcast_ref pada &dyn Describable memerlukan method cast eksplisit. Kini, coercion dari &dyn Describable ke &dyn Any terjadi secara implisit. Pola ini sangat berguna dalam sistem event dan arsitektur berbasis komponen yang membutuhkan inspeksi tipe saat runtime.

Trait AsyncFn: Async Closure Kelas Satu

Rust 1.85 menstabilkan async closure (async || {}) beserta tiga trait baru: AsyncFn, AsyncFnMut, dan AsyncFnOnce. Ketiganya menggantikan solusi lama yang memerlukan dua parameter generik (F: Fn() -> Fut, Fut: Future<Output = T>) dengan satu bound yang lebih ergonomis.

use std::time::Duration;
use tokio::time::sleep;

// Before Rust 1.85: two generic params needed
async fn retry_old<F, Fut>(max: usize, f: F) -> Result<String, String>
where
    F: Fn() -> Fut,
    Fut: std::future::Future<Output = Result<String, String>>,
{
    for _ in 0..max {
        if let Ok(val) = f().await {
            return Ok(val);
        }
    }
    Err("max retries reached".into())
}

// After Rust 1.85: single AsyncFn bound
async fn retry<F>(max: usize, f: F) -> Result<String, String>
where
    F: AsyncFn() -> Result<String, String>,
{
    for _ in 0..max {
        if let Ok(val) = f().await {
            return Ok(val);
        }
    }
    Err("max retries reached".into())
}

Bound AsyncFn lebih mudah dibaca dan menangani lifetime capture dengan benar. Hierarki trait ini mencerminkan versi sinkronnya: AsyncFn (borrow immutable) merupakan subtrait dari AsyncFnMut (borrow mutable), yang merupakan subtrait dari AsyncFnOnce (mengonsumsi capture). Memilih bound paling lemah yang dibutuhkan memberikan fleksibilitas maksimal bagi pemanggil.

Return-Position impl Trait dalam Trait (RPITIT)

Sejak Rust 1.75, method trait dapat mengembalikan -> impl Trait tanpa perlu boxing. Compiler melakukan desugaring menjadi associated type anonim, menyembunyikan tipe return konkret dari pemanggil sekaligus menghindari alokasi heap.

trait EventStream {
    // Each implementor returns its own iterator type — no Box needed
    fn events(&self) -> impl Iterator<Item = &str>;
}

struct FileLog {
    entries: Vec<String>,
}

impl EventStream for FileLog {
    fn events(&self) -> impl Iterator<Item = &str> {
        self.entries.iter().map(|s| s.as_str())
    }
}

struct MemoryLog {
    buffer: Vec<String>,
}

impl EventStream for MemoryLog {
    fn events(&self) -> impl Iterator<Item = &str> {
        self.buffer.iter().map(|s| s.as_str())
    }
}

Setiap implementor menyediakan iterator konkret yang berbeda. Trait menyembunyikan detail tersebut di balik impl Iterator. Satu keterbatasan yang perlu dicatat: tipe return RPITIT tidak kompatibel dengan dyn, sehingga &dyn EventStream tidak dapat digunakan dengan method yang mengembalikan impl Trait. Untuk dynamic dispatch, Box<dyn Iterator> tetap diperlukan.

Pola Generik Tingkat Lanjut: Trait Bound dan Where Clause

Kendala generik yang kompleks merupakan materi wawancara Rust yang klasik. Pola berikut menggabungkan associated type, trait bound, dan where clause untuk membangun pipeline yang type-safe.

use std::fmt::Display;

trait Transform {
    type Input;
    type Output: Display; // Output must be displayable

    fn apply(&self, input: Self::Input) -> Self::Output;
}

struct Uppercase;

impl Transform for Uppercase {
    type Input = String;
    type Output = String;

    fn apply(&self, input: String) -> String {
        input.to_uppercase()
    }
}

// Chain two transforms with compatible types
fn chain<A, B>(a: &A, b: &B, input: A::Input) -> B::Output
where
    A: Transform,
    B: Transform<Input = A::Output>,
{
    let mid = a.apply(input);
    b.apply(mid)
}

Klausa where B: Transform<Input = A::Output> memastikan pada waktu kompilasi bahwa output dari transform A sesuai dengan input dari transform B. Tidak ada pemeriksaan runtime, tidak ada unwrapping -- sistem tipe menjamin kebenaran secara otomatis.

Pola ini dapat diperluas dengan menambahkan constraint tambahan. Misalnya, jika setiap tahap pipeline perlu dapat di-debug, cukup tambahkan bound A: Transform + Debug pada where clause. Kemampuan untuk menyusun constraint secara deklaratif inilah yang menjadikan generics Rust sangat ekspresif untuk membangun abstraksi yang aman.

Aturan Lifetime Capture dan Bound use<..>

Rust 2024 Edition mengubah cara -> impl Trait menangkap lifetime. Sebelumnya, RPIT pada free function hanya menangkap parameter type dan const. Kini, secara default, seluruh parameter generik yang berada dalam scope turut ditangkap, termasuk lifetime. Sintaks use<..> memberikan kontrol eksplisit ketika capture yang lebih sempit dibutuhkan.

// Captures both 'a and T by default in 2024 Edition
fn filtered_items<'a, T: 'a>(
    items: &'a [T],
    predicate: fn(&T) -> bool,
) -> impl Iterator<Item = &'a T> {
    items.iter().filter(move |item| predicate(item))
}

// Explicit capture: only capture 'a and T, not other lifetimes
fn explicit_capture<'a, 'b, T: 'a>(
    items: &'a [T],
    _label: &'b str,
) -> impl Iterator<Item = &'a T> + use<'a, T> {
    items.iter()
}

Bound use<'a, T> memberi tahu compiler bahwa tipe opaque yang dikembalikan hanya bergantung pada 'a dan T, bukan pada 'b. Hal ini menghindari constraint lifetime yang tidak perlu, yang jika tidak ditangani akan mencegah pemanggil untuk meng-drop _label sebelum mengonsumsi iterator.

Perubahan ini berdampak signifikan pada kode yang menggunakan banyak parameter lifetime. Di edisi sebelumnya, developer seringkali tidak menyadari bahwa return type secara implisit tidak menangkap lifetime tertentu. Dengan perilaku baru yang menangkap semua lifetime secara default, kode menjadi lebih aman, dan use<..> tersedia sebagai mekanisme opt-out ketika diperlukan.

Pertanyaan Wawancara: Traits dan Generics Secara Mendalam

Pertanyaan-pertanyaan berikut secara rutin muncul dalam wawancara Rust di perusahaan yang menggunakan Rust di lingkungan produksi. Setiap pertanyaan menargetkan konsep spesifik yang membedakan kandidat yang sekadar membaca dokumentasi dari mereka yang membangun sistem nyata.

T1: Apa perbedaan antara impl Trait dan dyn Trait sebagai tipe return fungsi?

impl Trait mengembalikan satu tipe konkret yang ditentukan oleh body fungsi. Compiler melakukan monomorphization pada setiap call site. dyn Trait mengembalikan trait object dengan dynamic dispatch berbasis vtable, memungkinkan tipe konkret yang berbeda dikembalikan dari jalur kode yang berbeda. impl Trait bersifat zero-cost tetapi membatasi fungsi untuk mengembalikan tepat satu tipe. dyn Trait menambahkan alokasi heap (melalui Box) dan satu pointer indirection per pemanggilan.

T2: Dapatkah method trait yang mengembalikan impl Trait tetap digunakan dengan dynamic dispatch?

Tidak. Method yang mengembalikan -> impl Trait menjadikan trait tersebut tidak kompatibel dengan dyn (sebelumnya disebut "non-object-safe"). Compiler tidak dapat menentukan tipe return konkret di balik vtable. Solusinya adalah mengembalikan Box<dyn Trait> sebagai gantinya, atau memisahkan trait menjadi base trait yang kompatibel dengan dyn dan extension trait yang bersifat generik.

T3: Jelaskan trait coherence dan orphan rule.

Rust memastikan bahwa paling banyak satu impl dari trait tertentu yang ada untuk tipe tertentu. Orphan rule membatasi implementasi trait hanya pada crate yang mendefinisikan trait tersebut atau tipe tersebut. Aturan ini mencegah implementasi yang saling bertentangan antar dependency. Pola newtype (struct Wrapper(Inner)) merupakan solusi standar ketika implementasi untuk tipe asing dengan trait asing dibutuhkan.

T4: Bagaimana trait upcasting mengubah pola penanganan error?

Dengan trait upcasting (Rust 1.86+), tipe error kustom yang mengimplementasikan trait error domain-spesifik dan std::error::Error (yang memiliki Debug + Display sebagai supertrait) dapat secara otomatis di-upcast ke &dyn Error. Sebelum versi 1.86, mengonversi Box<dyn CustomError> menjadi Box<dyn Error> memerlukan implementasi From secara manual atau method helper. Upcasting menghilangkan boilerplate tersebut.

T5: Masalah apa yang diselesaikan oleh trait AsyncFn yang tidak dapat diatasi oleh Fn() -> impl Future?

Bound Fn() -> impl Future<Output = T> tidak dapat mengekspresikan dengan benar bahwa future yang dikembalikan melakukan borrow dari state yang di-capture oleh closure. Hal ini menyebabkan error lifetime ketika future perlu mereferensikan data yang dimiliki oleh closure. Trait AsyncFn menangani ini dengan benar karena compiler memahami hubungan antara capture closure dan lifetime future. RFC 3668 menjelaskan semantik persisnya secara mendetail.

Untuk pertanyaan wawancara Rust tambahan yang mencakup ownership dan borrowing serta async/await dengan Tokio, set latihan lengkap tersedia di jalur persiapan wawancara Rust.

Kesimpulan

• Trait upcasting (Rust 1.86) menghilangkan boilerplate manual as_supertrait(). Rancang hierarki trait dengan Any sebagai supertrait ketika inspeksi tipe saat runtime diperlukan.
• AsyncFn, AsyncFnMut, dan AsyncFnOnce (Rust 1.85) menggantikan pola Fn() -> Fut, Fut: Future. Gunakan bound paling lemah yang memenuhi kebutuhan call-site.
• RPITIT (Rust 1.75+) memungkinkan method trait mengembalikan -> impl Trait tanpa boxing. Perlu diingat bahwa fitur ini menghilangkan kompatibilitas dyn.
• Bound use<..> pada edisi 2024 memberikan kontrol eksplisit atas lifetime mana yang ditangkap oleh tipe return impl Trait.
• Pertanyaan wawancara tentang traits menguji tiga hal: trade-off static vs. dynamic dispatch, aturan coherence, dan kemampuan merancang hierarki trait yang tetap dapat diperluas.
• Pastikan kode berjalan pada Rust 1.86+ untuk mengakses seluruh fitur yang dibahas dalam panduan ini. Jalankan rustup update stable untuk memastikan toolchain terbaru terpasang.