Lewati ke konten
Ferris the Rust crabTutorial Rust

Error Rust E0658: use of unstable library feature (fitur khusus nightly)

E0658 artinya: kamu memakai sesuatu yang memang ada di Rust, tapi belum selesai, jadi Rust stable tidak mengizinkanmu memakainya. Biasanya ini sebuah method yang kamu temukan di dokumentasi standard library atau di sebuah artikel blog, seperti .intersperse() atau .try_collect(), atau sepotong sintaks seperti try { ... }. Kodemu tidak salah, dan tidak ada yang rusak di komputermu. Kamu cuma meraih fitur yang hanya berfungsi di compiler nightly. Hampir selalu, ada cara stabil untuk melakukan hal yang sama dalam satu baris. (Halaman ini bagian dari Penjelasan error compiler Rust.)

Pesan error-nya

Section titled “Pesan error-nya”
error[E0658]: use of unstable library feature `iter_intersperse`
 --> src/main.rs:3:47
  |
3 |     let joined: String = tags.iter().copied().intersperse(", ").collect(); // ❌ nightly-only method
  |                                               ^^^^^^^^^^^
  |
  = note: see issue #79524 <https://github.com/rust-lang/rust/issues/79524> for more information

Artinya: kamu memakai fitur library yang belum stabil, iter_intersperse. note:-nya menunjuk ke issue GitHub untuk informasi lebih lanjut.

Ini program yang menghasilkan error tersebut:

fn main() {
    let tags = ["rust", "web", "cli"];
    let joined: String = tags.iter().copied().intersperse(", ").collect(); // ❌ nightly-only method
    println!("{}", joined);
}

Apa artinya

Section titled “Apa artinya”

Tanda ^^^^^^^^^^^ menunjuk ke intersperse di baris 3. Judul error-nya menyebut nama fitur di antara backtick, iter_intersperse. Itu nama yang dipakai tim Rust untuk bagian standard library yang belum selesai ini. note:-nya menautkan issue GitHub tempat fitur itu sedang didiskusikan.

Jadi rustc menemukan method-nya. Ia tahu persis apa maksudmu. Ia cuma tidak mau meng-compile-nya, karena intersperse masih ditandai unstable (belum stabil): nama, argumen, atau perilakunya bisa berubah sebelum selesai, atau bahkan bisa dihapus.

Bentuk judul lain berarti hal yang sama untuk fitur bahasa, bukan fitur library: the `!` type is experimental (tipe ! masih eksperimental), `try` expression is experimental (ekspresi try masih eksperimental), atau associated type defaults are unstable (nilai default associated type belum stabil).

Ibaratnya toko yang memajang produk baru di rak dengan stiker “khusus staf, masih diuji”. Kamu bisa melihatnya, kamu bisa membaca labelnya, tapi kasir belum mau menjualnya kepadamu.

Kenapa Rust melakukan ini

Section titled “Kenapa Rust melakukan ini”

Rust membuat janji yang kuat: kode yang ter-compile di Rust stable hari ini akan tetap ter-compile di setiap versi Rust 1.x stable berikutnya. Untuk menepati janji itu, fitur baru masuk dulu ke kanal nightly, tempat orang bisa mencobanya dan desainnya masih bisa berubah. Baru setelah sebuah fitur selesai, fitur itu menjadi stabil, biasanya setelah berbulan-bulan atau bertahun-tahun diuji.

Rust stable sama sekali menolak meng-compile fitur yang belum stabil, jadi kamu tidak bisa membangun di atas sesuatu yang mungkin berubah. Kalau kamu benar-benar ingin mencobanya, nightly mengizinkanmu menyalakannya berdasarkan nama dengan #![feature(iter_intersperse)]. Di stable, baris itu sendiri sudah error (E0554).

Dokumentasi standard library menampilkan kedua jenisnya berdampingan. Item yang stabil punya nomor versi di sebelah kanan, seperti 1.82.0: versi Rust saat item itu menjadi stabil. Item yang belum stabil punya kotak bertuliskan “🔬 This is a nightly-only experimental API.” (ini API eksperimental khusus nightly). Kotak itu cara tercepat untuk mengenali E0658 sebelum kamu menulis kode apa pun. Lihat Tools dan setup Rust untuk tahu bagaimana kanal Rust dan rustup saling terkait.

Cara memperbaikinya

Section titled “Cara memperbaikinya”

Perbaikan 1: Pakai alternatif yang stabil

Section titled “Perbaikan 1: Pakai alternatif yang stabil”

Pilih ini hampir setiap saat. Method yang belum stabil biasanya adalah jalan pintas untuk sesuatu yang sudah bisa dilakukan Rust stable. Untuk menggabungkan string dengan pemisah, join pada slice atau Vec melakukan hal yang sama dengan intersperse(...).collect():

fn main() {
    let tags = ["rust", "web", "cli"];
    let joined = tags.join(", ");
    println!("{}", joined);


    // String yang dibuat oleh iterator: kumpulkan dulu ke Vec, lalu join.
    let upper: Vec<String> = tags.iter().map(|t| t.to_uppercase()).collect();
    println!("{}", upper.join(" | "));
}

Output:

rust, web, cli
RUST | WEB | CLI
▶ Coba sendiri

Kalau kamu lebih suka semuanya tetap dalam satu rantai iterator, crate populer itertools punya join dan intersperse yang stabil untuk iterator. Lihat String dan Iterator.

Perbaikan 2: Cek dokumentasinya untuk tanda “nightly-only”

Section titled “Perbaikan 2: Cek dokumentasinya untuk tanda “nightly-only””

Pilih ini kalau kamu menyalin sebuah method dari dokumentasi, jawaban AI, atau artikel blog. Buka method itu di dokumentasi std: kalau ada kotak 🔬, cari sedikit lagi untuk cara yang stabil. Contoh yang umum adalah .try_collect():

error[E0658]: use of unstable library feature `iterator_try_collect`
 --> src/main.rs:3:80
  |
3 |     let numbers: Result<Vec<i32>, _> = inputs.iter().map(|s| s.parse::<i32>()).try_collect(); // ❌ nightly-only
  |                                                                                ^^^^^^^^^^^
  |
  = note: see issue #94047 <https://github.com/rust-lang/rust/issues/94047> for more information

Artinya: fitur library iterator_try_collect belum stabil. Program yang rusak:

fn main() {
    let inputs = ["3", "14", "x"];
    let numbers: Result<Vec<i32>, _> = inputs.iter().map(|s| s.parse::<i32>()).try_collect(); // ❌ nightly-only
    println!("{:?}", numbers);
}

Rust stable sudah bisa melakukan ini dengan collect() biasa. Kalau item-nya berupa Result dan kamu mengumpulkannya ke Result<Vec<_>, _>, kamu mendapat Ok berisi semua nilainya, atau Err yang pertama:

use std::num::ParseIntError;


fn parse_all(inputs: &[&str]) -> Result<Vec<i32>, ParseIntError> {
    inputs.iter().map(|s| s.parse::<i32>()).collect()
}


fn main() {
    println!("{:?}", parse_all(&["3", "14", "15"]));
    println!("{:?}", parse_all(&["3", "x", "15"]));
}

Output:

Ok([3, 14, 15])
Err(ParseIntError { kind: InvalidDigit })
▶ Coba sendiri

Fitur belum stabil lain yang mungkin kamu temui, beserta jalan stabilnya: .array_chunks() pada iterator (iter_array_chunks; pakai .as_chunks() atau .chunks() pada slice), dan .map_windows() (pakai .windows() pada slice). Lihat Result dan Slice.

Perbaikan 3: Update Rust kalau fiturnya baru saja distabilkan

Section titled “Perbaikan 3: Update Rust kalau fiturnya baru saja distabilkan”

Pilih ini kalau dokumentasinya menampilkan nomor versi, bukan kotak 🔬, atau kode yang sama bisa ter-compile di komputer temanmu atau di Playground. Berarti fiturnya sudah stabil, hanya lebih baru daripada compiler-mu. Misalnya, as_chunks pada slice menjadi stabil di Rust 1.88. Di Rust yang lebih lama kamu akan mendapat E0658; di versi terbaru, kode ini langsung jalan:

fn main() {
    let readings = [21, 22, 19, 20, 23];
    let (pairs, rest) = readings.as_chunks::<2>();
    for [a, b] in pairs {
        println!("{} dan {}", a, b);
    }
    println!("sisa: {:?}", rest);
}

Output:

21 dan 22
19 dan 20
sisa: [23]
▶ Coba sendiri

Cek versimu, lalu update:

Terminal window
rustc --version
rustup update

Kalau rustc --version masih menampilkan versi lama setelahnya, cari file rust-toolchain.toml di proyekmu. File itu mengunci proyek ke satu versi Rust, dan rustup show memberi tahu versi mana yang sedang aktif. Lihat Tools dan setup Rust.

Perbaikan 4: Pakai nightly dengan #![feature], hanya kalau kamu benar-benar yakin

Section titled “Perbaikan 4: Pakai nightly dengan #![feature], hanya kalau kamu benar-benar yakin”

Pilih ini paling akhir, dan hanya kalau tidak ada alternatif stabil dan kamu tidak keberatan kodemu rusak di nightly berikutnya. Kamu butuh dua hal: baris #![feature(...)] di bagian atas main.rs (atau lib.rs) dengan nama fitur dari error-nya, dan compiler nightly. Di stable, baris #![feature] itu sendiri ditolak:

error[E0554]: `#![feature]` may not be used on the stable release channel
 --> src/main.rs:1:1
  |
1 | #![feature(iter_intersperse)] // ❌ only allowed on nightly Rust
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Artinya: #![feature] tidak boleh dipakai di kanal rilis stable. Programnya, yang hanya bisa di-build di nightly:

#![feature(iter_intersperse)] // ❌ only allowed on nightly Rust


fn main() {
    let tags = ["rust", "web", "cli"];
    let joined: String = tags.iter().copied().intersperse(", ").collect();
    println!("{}", joined);
}

Instal nightly di samping Rust stable-mu, dan pakai hanya untuk proyek ini atau perintah ini:

Terminal window
rustup toolchain install nightly
cargo +nightly run

Jujurlah pada dirimu sendiri di sini. Untuk belajar, test, dan tool kecil, nightly tidak masalah. Untuk library yang dipakai orang lain, atau apa pun yang harus kamu rawat, tetaplah di stable: sebagian besar crate yang kamu pakai juga begitu.

Di mana biasanya kamu melihatnya

Section titled “Di mana biasanya kamu melihatnya”

Vec<i32, i32> padahal maksudmu daftar pasangan. Parameter kedua Vec adalah alokator memori, yang belum stabil, jadi error pertamanya tentang allocator_api (beberapa error lain menyusul):

error[E0658]: use of unstable library feature `allocator_api`
 --> src/main.rs:2:26
  |
2 |     let points: Vec<i32, i32> = vec![]; // ❌ meant a list of (x, y) pairs
  |                     -----^^^
  |                     |
  |                     help: consider wrapping the inner types in tuple: `(i32, i32)`
fn main() {
    let points: Vec<i32, i32> = vec![]; // ❌ meant a list of (x, y) pairs
    println!("{} points", points.len());
}

Help-nya menyarankan membungkus tipe di dalamnya menjadi tuple. Perbaikannya: lakukan sesuai saran help, Vec<(i32, i32)>. Lihat Vektor dan Tuple. Kesalahan yang sama pada Option atau Result adalah E0107.

Tipe ! di signature buatanmu sendiri. ! artinya “tidak pernah terjadi”. Tipe ini bisa dipakai sebagai tipe kembalian fungsi yang tidak pernah kembali, tapi di tempat lain masih belum stabil:

error[E0658]: the `!` type is experimental
 --> src/main.rs:1:34
  |
1 | fn default_port() -> Result<u16, !> { // ❌ the `!` type is nightly-only here
  |                                  ^
fn default_port() -> Result<u16, !> { // ❌ the `!` type is nightly-only here
    Ok(8080)
}


fn main() {
    println!("{:?}", default_port());
}

Perbaikannya: pakai std::convert::Infallible, tipe stabil untuk “error ini tidak mungkin terjadi”, atau cukup kembalikan u16 kalau memang tidak ada yang bisa gagal.

Blok try. Blok try { ... } memungkinkanmu memakai ? tanpa menulis fungsi, tapi itu khusus nightly (`try` expression is experimental). Perbaikannya: pindahkan kodenya ke fungsi kecil yang mengembalikan Result lalu pakai ? di sana, seperti di Perbaikan 2. Lihat Result.

Terkait, tapi bukan E0658: kode yang ditulis untuk edition 2024, seperti if let Some(a) = age && a >= 18, memberi let chains are only allowed in Rust 2024 or later (let chain hanya diizinkan di Rust 2024 atau sesudahnya) di edition yang lebih lama. Perbaikannya: set edition = "2024" di Cargo.toml, atau tulis dua if bersarang.

Error terkait

Section titled “Error terkait”
  • E0554: #![feature] may not be used on the stable release channel, error lanjutan saat kamu mencoba Perbaikan 4 di stable.
  • E0599: no method found; kalau method-nya sama sekali tidak ada (atau berasal dari crate yang belum kamu tambahkan), kamu mendapat error ini.
  • E0107: jumlah argumen generic salah, seperti Option<i32, i32> (saudara dari kasus Vec<i32, i32>).
  • E0277: trait bound tidak terpenuhi; salah satu error yang menyusul Vec<i32, i32>.
  • E0463: can’t find crate, kalau kamu beralih ke itertools tapi lupa menambahkannya ke Cargo.toml.
  • Semua error compiler: daftar lengkap halaman error.

Kuis singkat

Section titled “Kuis singkat”

Kuis singkat

1. Halaman dokumentasi std sebuah method menampilkan kotak "This is a nightly-only experimental API". Apa yang terjadi kalau kamu memanggilnya di Rust stable?

2. .try_collect() memberi E0658. Apa cara stabil yang biasa untuk mengubah iterator berisi Result menjadi Result<Vec<_>, _>?

3. Kode yang bisa ter-compile di Playground memberimu E0658 untuk method yang dokumentasinya menampilkan 1.88.0. Apa yang sebaiknya dicoba dulu?

Skor: 0 / 3

Bacaan lebih lanjut

Section titled “Bacaan lebih lanjut”