Artikel mendalam tentang teknologi yang membentuk masa depan.

Rust 1.100: Never Type, Setelah Sepuluh Tahun Dinanti

Rust 1.100 akhirnya menstabilkan never type, custom allocator, dan cooldown dependensi Cargo. Apa yang diajarkan 100 rilis sabar tentang desain bahasa.

Tangga batu panjang yang dibangun selangkah demi selangkah menanjak di lereng bukit, dengan peralatan tukang batu tergeletak di tengah pembangunan
Seratus anak tangga kecil yang rata: ritme rilis Rust sebagai filosofi konstruksi.

Ini skenario yang seharusnya luar biasa tapi ternyata tidak: kamu menjalankan rustup update stable di pagi Kamis, membangun ulang workspace dengan beberapa ratus crate dan setengah juta baris kode, dan semuanya berhasil dikompilasi. Tidak ada peringatan deprecation yang tidak perlu, tidak ada breaking change kejutan di dependensi transitif, tidak ada pinning versi yang panik-panikan. Dengan Rust 1.100 — rilis yang benar-benar besar dan akhirnya menghadirkan never type setelah satu dekade percobaan — hal paling menarik darinya justru betapa membosankannya proses upgrade ini bagi hampir semua orang. Ini bukan kebetulan. Ini hasil dari disiplin institusional seratusan rilis, dan layak dibaca seperti kamu membaca dokumen desain.

Never Type, Dinanti Selama Satu Dekade

Fitur utama 1.100 adalah sebuah tipe yang, menurut definisinya, tidak punya nilai. Never type, ditulis !, adalah tipe kosong yang paling kanonik: ia mendeskripsikan komputasi yang tidak pernah menghasilkan nilai — loop tak terbatas, return, panic!(), pemanggilan std::process::exit. Para ahli teori tipe sudah lama mengenal konsep ini; ini adalah bottom type, ⊥ dalam lambda calculus, himpunan kosong yang berdiri di pojok type lattice-mu. Pengguna Haskell mengenalnya sebagai Void. Rust sudah berputar-putar di sekitar konsep ini sejak sebelum 1.0, dan butuh sepuluh tahun serta lima kali percobaan stabilisasi yang gagal untuk akhirnya menetap.

Kenapa sesulit itu? Karena ! bisa di-coerce ke tipe apa pun — dan justru di situlah kekuatannya — dan setiap titik coercion adalah tempat di mana type inference, trait resolution, dan exhaustiveness checking harus sepakat. Karena sebuah match arm yang divergen punya tipe !, kode berikut bisa dikompilasi:

fn infallible_unwrap<T>(res: Result<T, !>) -> T {
// ^^ naming `!` in a type position like this
// was not allowed on stable before 1.100
let Ok(v) = res;
v
}

Baris let Ok(v) = res; adalah hasil akhirnya: karena Err(!) tidak mungkin ada, compiler menerima pola yang irrefutable, dan seluruh kategori pemanggilan unreachable!() defensif jadi tidak perlu lagi. Selain itu, enum std::convert::Infallible lama kini menjadi type alias untuk !, sehingga setiap API yang ditulis dengan Infallible selama beberapa tahun terakhir otomatis kompatibel dengan never type yang sebenarnya. Penyatuan ini memang rencana sejak awal — dan juga alasan stabilisasinya terus molor, karena mengubah alias tersebut berarti mengubah fallback never type di edisi sebelum 2024, yang secara teknis merupakan breaking change.

Lihat bagaimana tim menangani breaking change itu, karena di situlah seluruh filosofinya terangkum. Mereka merilis peringatan future-compatibility jauh-jauh hari, melakukan crater test ke seluruh ekosistem, dan proaktif mengirim perbaikan ke crate publik yang akan terdampak. Sebuah breaking change yang dieksekusi lintas beberapa siklus rilis, dengan dampaknya diukur dan ditambal sebelum kebanyakan pengguna sadar. Bandingkan dengan kebiasaan industri yang umum: naikkan versi mayor lalu angkat bahu. Saya pernah menulis tentang komitmen apa yang sebenarnya diikat oleh soundness di Rust — saga never type ini adalah versi level proses dari komitmen yang sama. Ketika jaminanmu adalah "kode aman tidak boleh punya undefined behavior", bahkan tipe tanpa satu pun inhabitant pun harus membuktikan dirinya layak masuk.

Custom Allocator Akhirnya Punya Fondasi Stabil

Hampir sama dinantinya: inti dari pekerjaan allocator_api sudah stabil. Trait Allocator, Global, System, dan konstruktor *_in — Vec::new_in, Vec::with_capacity_in, Box::new_in, Box::from_raw_in — sekarang sudah bisa dipakai di Rust stabil. Library author bisa mendefinisikan allocator dan menyerahkannya ke koleksi standar:

use std::alloc::{Allocator, Global};
// A Vec that allocates from your arena/pool/slab instead of the heap
let mut v: Vec<u64, _> = Vec::new_in(MyArena::new());
v.push(42);

Kalau kamu cuma pernah menulis kode aplikasi, ini mungkin terdengar seperti plumbing. Memang plumbing — dan di situlah bahasa sistem hidup atau mati. Sampai sekarang, mengganti allocator berarti memakai alat tumpul #[global_allocator]: satu allocator untuk seluruh proses. Itu oke kalau kamu memang ingin jemalloc atau mimalloc di mana-mana (dan performanya memang nyata — jemalloc memang layak reputasinya dalam skala besar), tapi tidak berguna kalau kamu ingin satu Vec yang dibackup arena dan dibebaskan sekaligus di akhir sebuah request, sementara sisanya tetap memakai default heap. Game engine, database, target embedded dengan beberapa region RAM, kode dekat kernel — semuanya menginginkan kontrol per koleksi, dan sudah menginginkannya selama bertahun-tahun.

Perhatikan framing di rilis itu sendiri: ini secara eksplisit adalah fondasi dari project goal "Allocators 1.0", dengan lebih banyak koleksi dan pointer type menyusul. Tim Rust sudah nyaman mengatakan "ini inti yang stabil; sisanya sengaja masih nightly". Urutan seperti itu — stabilkan trait dan desainnya, biarkan ekosistem membangun di atasnya, perluas permukaan API nanti — adalah cara tepat untuk menghindari terjebak dengan API yang harus didukung selamanya. C++ mengambil jalan sebaliknya dengan std::allocator di era sembilan puluhan, merilisnya setengah matang, dan menghabiskan puluhan tahun mengakali kekacauannya. Sabar itu lebih murah.

DropGuard: defer-nya Go, versi Rust

Kejutan tersembunyi dari rilis ini adalah std::mem::DropGuard. Trait Drop di Rust sudah menjamin bahwa kode cleanup dijalankan ketika sebuah value keluar dari scope — return, ?, panic, tidak peduli. Tapi menulis tipe baru hanya untuk menjalankan closure saat keluar adalah boilerplate yang sudah dikeluhkan banyak dari kita. DropGuard membungkus sebuah value dan sebuah closure, melakukan deref ke value tersebut sehingga bisa dipakai secara normal, dan menjalankan closure saat guard itu mati. Method dismiss() bisa menonaktifkannya. Penggunaan kanonisnya adalah rollback transaksi:

use std::mem::DropGuard;
use std::num::ParseIntError;
/// Push every parsed string into `nums`, or leave `nums` untouched.
fn parse_all(nums: &mut Vec<u32>, strings: &[&str]) -> Result<(), ParseIntError> {
let len = nums.len();
let mut nums = DropGuard::new(nums, move |nums| {
nums.truncate(len); // rollback on failure
});
for s in strings {
nums.push(s.parse()?); // `?` exits early; the guard truncates
}
DropGuard::dismiss(nums); // success: keep the values
Ok(())
}

Kalau ini terasa seperti defer di Go, memang begitu — tapi dengan perbedaan krusial di mana jaminan itu berada. defer di Go adalah statement yang terikat pada fungsi: ia berjalan saat fungsi return, dan tidak terlihat oleh type system. DropGuard adalah sebuah value. Kamu bisa memindahkannya, menyimpannya, menyerahkannya ke scope lain, atau menonaktifkannya secara kondisional. Garis keturunannya mengarah ke RAII C++ dan trik ScopeGuard milik Alexandrescu dari awal C++ modern, yang melakukan hal serupa dengan destructor dan pemanggilan Dismiss(). Rust tidak menciptakan ide ini; ia menyerap idiom C++ yang sudah berusia dua puluh tahun, memberinya semantik ownership, dan memasukkannya ke core. Begitulah evolusi bahasa yang baik bekerja — bukan kebaruan, tapi adopsi pola yang sudah terbukti ke dalam kosakata standar.

Pemain tali berjalan melintasi ngarai dengan tali pengaman yang terikat di belakangnya
DropGuard adalah tali pengaman yang terikat: apa pun yang terjadi di kawat, rollback tetap berjalan.

Menciptakan Yang Tak Ada: Zero-Sized Type dengan Benar

Lebih dalam di catatan rilis ada sebuah fungsi dengan nama yang sangat saya suka: std::mem::conjure_zst. Zero-sized type — unit struct, token marker seperti Python<'py milik PyO3 — ada di mana-mana dalam pemrograman level tipe Rust. Jika sebuah tipe yang punya inhabitant tidak punya ukuran, berarti hanya ada satu nilai yang bisa ditampungnya, jadi membuatnya dalam arti tertentu selalu "aman". Tapi API sering mengandalkan token itu agar tidak bisa dipalsukan: memunculkan Python<'py dari udara kosong akan membuat kode aman berpura-pura memegang GIL. Sebelumnya, orang memanggil ZST dengan transmute dari () atau mantra MaybeUninit, masing-masing dengan implikasi halus yang berbeda terhadap pedoman unsafe code yang masih belum diputuskan. Sekarang ada satu ejaan resmi yang jelas-jelas unsafe. Ini fungsi kecil yang ada agar sebuah pertanyaan spesifikasi besar punya satu jawaban yang bisa diaudit. Sederhana, hati-hati, benar — seluruh rilis ini dalam satu API.

Cooldown Dependensi Cargo: Pertahanan Supply Chain dengan Timer

Perubahan paling berdampak di 1.100 mungkin tidak ada di bahasanya sama sekali. Cargo kini mendukung resolusi dependensi yang sadar min-publish-age — cooldown dependensi. Dasarnya empiris: versi package berbahaya biasanya tertangkap dalam hitungan jam atau hari setelah publikasi, oleh scanner maupun manusia. Maka cukup tolak resolve ke versi yang lebih muda dari jendela waktu yang dikonfigurasi:

# .cargo/config.toml
[registry]
global-min-publish-age = "3 days"

Sejak itu, cargo update diam-diam melewati rilis baru dan memberi tahu apa yang ditahannya — clap 4.6.7 (available: 4.6.9, published 2 days ago). Saat kamu benar-benar butuh hot fix, override lewat environment variable satu kali memungkinkanmu menariknya secara sengaja, dan pilihan itu tercatat di Cargo.lock alih-alih menyebar diam-diam. Ini kontrol keamanan langka yang hampir tidak memakan biaya: kamu menukar beberapa hari kesegaran versi dengan karantina permanen terhadap serangan package zero-day yang tertangkap cepat. Mengingat apa yang sudah kita lihat terjadi di registry lain — kompromi LiteLLM di PyPI adalah masterclass terbaru tentang seberapa cepat rilis yang diracuni menyebar — cooldown adalah asuransi termurah di ekosistem. Catatan rilisnya cukup jujur bahwa ini bukan pertahanan yang lengkap, dan cargo install melewatinya sepenuhnya. Dukungan karantina dan deteksi otomatis rilis mencurigakan masih ada di roadmap crates.io. Pertahanan berlapis, dikirim satu lapis demi satu.

Kebersihan Build: Dependensi Tak Terpakai dan Tabrakan Cache

Dua perubahan quality-of-life layak disebut karena menyerang dua keluhan paling umum di setiap thread Rust: waktu kompilasi dan penggunaan disk. Pertama, Cargo sekarang melaporkan dependensi tak terpakai secara langsung, dengan peringatan yang menunjuk baris persis di Cargo.toml-mu. Rustc sudah punya lint unused_crate_dependencies sejak lama, tapi menghasilkan false positive dengan Cargo karena dependensi dibagi antar build target — dep yang dipakai satu bin dalam sebuah package terlihat tidak terpakai bagi target lain. Cargo punya pandangan global yang tidak dimiliki rustc, jadi peringatannya sekarang berada di tempat kebenaran berada. Fitur ini berada di balik build semua target yang relevan, dan merupakan warga pertama dari sistem linting baru [lints.cargo] untuk manifest itu sendiri.

Kedua, direktori build direorganisasi. Konfigurasi build yang berbeda — feature set, profile — menghasilkan artifact yang berbeda, dan sebuah hash konfigurasi menjaganya tetap terpisah. Hash itu tidak diterapkan secara konsisten karena keterbatasan platform, sehingga muncul rebuild ekstra, rebuild yang terlewat, dan kebingungan umum, dan semuanya makin parah jika kamu berbagi build directory di antara git worktree. Perbaikannya memindahkan hash dari nama file ke struktur direktori yang diatur per build step. Tak terlihat saat berfungsi, dan itu intinya — serta membuka jalan bagi garbage collection cache dan deduplikasi lintas workspace di kemudian hari. Kalau direktori target/-mu pernah memakan 90 gigabyte dan memaksamu menjalankan cargo clean setiap hari, fondasi penyelamatanmu baru saja diletakkan. Perbaikan penuhnya belum ada di sini, tapi refactor yang menanggung beban utamanya sudah.

Gudang luas dengan crate yang ditumpuk rapi dalam baris teratur dan sudut karantina yang dipagari tali
Cooldown dan kebersihan cache: logistik membosankan yang menjaga kepercayaan ekosistem package.

Apa yang Diajarkan Seratus Rilis tentang Evolusi Bahasa

Stabilitas bukan berarti tidak ada perubahan. Ini adalah disiplin mengatur urutan perubahan agar kode siapa pun tidak ikut membayar harga roadmap-mu.

Coba mundur dan lihat bentuk rilis ini. Penyempurnaan teori tipe yang memakan satu dekade. Trait allocator yang sengaja dirilis sebagai fondasi, bukan permukaan final. Idiom scope-guard yang lebih tua dari sebagian penggunanya, akhirnya distandarisasi. Fitur keamanan yang dibangun di atas metadata registry dan caveat yang jujur. Internal build system yang direfactor untuk membuka pekerjaan masa depan. Tak satu pun dari ini adalah pergeseran paradigma yang mencuri perhatian, tapi bersama-sama mereka adalah hal itu: bahasa yang terus makin dalam tanpa berubah di bawah kakimu. Ini sama dengan akumulasi tenang yang kamu lihat di langkah maju Java yang tidak glamor, ekosistem lain yang sudah paham bahwa membosankan adalah sebuah fitur.

Mesin yang membuat semua ini mungkin layak dapat kredit sebanyak fitur mana pun. Model train enam minggu berarti tidak ada stabilisasi yang pernah jadi darurat. Crater — alat yang mengompilasi hampir seluruh ekosistem crate publik terhadap kandidat compiler — mengubah pertanyaan "apakah ini akan merusak seseorang?" dari doa menjadi pengukuran. Edition menyediakan jalur migrasi opt-in sehingga bahasa bisa mengubah default-nya tanpa mengubah kodemu. Dan institusi yang relatif baru, yaitu project goal bernama (Allocators 1.0, tata letak build directory, pengerasan supply chain crates.io), memberi upaya bertahun-tahun sebuah tulang punggung publik, sehingga fitur seperti never type bisa gagal lima kali dan tetap punya jalur yang ditunjuk untuk pulang, alih-alih mati di thread mailing list.

Ada pelajaran di sini untuk siapa pun yang memelihara platform, protokol, atau library yang banyak dipakai. Pengguna tidak merasakan roadmap-mu; mereka merasakan diff-mu. Never type yang masuk di 1.100 alih-alih 1.35 bukan cerita tentang lambatnya — ini cerita tentang apa yang terjadi ketika sebuah proyek menganggap "kita akan tahu saat melihatnya" sebagai jawaban yang dapat diterima selama satu dekade. Kebanyakan organisasi software tidak mampu membayar kesabaran seperti itu, dan jujur saja kebanyakan memang tidak membutuhkannya. Tapi kalau kamu membangun sesuatu yang dibangun di atas-nya orang lain, hitungannya berbalik: kepercayaan penggunamu berbunga seperti bunga majemuk, dan satu-satunya cara mendapatkannya adalah seratus rilis di mana tidak ada yang rusak. Rust 1.100 adalah rilis besar. Cerita yang lebih besar adalah kamu bisa menginstalnya tanpa harus membaca catatan rilisnya dulu.