भविष्य को आकार देने वाली तकनीक पर गहन लेख।

Rust 1.100: दस साल बाद आया Never Type

Rust 1.100 में never type, custom allocators और Cargo dependency cooldowns स्थिर हुए। सौ releases से भाषा डिज़ाइन के बारे में क्या सीखें, जानिए।

पहाड़ी पर एक-एक क़दम करके बनती पत्थर की एक लंबी सीढ़ी, बीच निर्माण में राजमिस्त्री के औज़ार रखे हुए
एक-एक करके बने सौ छोटे, समतल क़दम: Rust का release cadence एक construction philosophy की तरह।

कल्पना कीजिए एक ऐसी स्थिति की जो असल में हैरान करने वाली होनी चाहिए, लेकिन होती नहीं: गुरुवार सुबह आप rustup update stable चलाते हैं, कुछ सौ crates और पाँच लाख लाइन वाला workspace दोबारा build करते हैं, और सब कुछ compile हो जाता है। कोई ऐसी deprecation warning नहीं जो आपने कमाई न हो, किसी transitive dependency में कोई अचानक टूट-फूट नहीं, versions को जल्दी-जल्दी pin करने की कोई हड़बड़ी नहीं। Rust 1.100 — जो सच में एक बड़ी release है और दस साल की कोशिशों के बाद never type लेकर आई है — उसकी सबसे दिलचस्प बात यह है कि लगभग हर किसी के लिए इसका upgrade कितना नीरस रहेगा। यह कोई इत्तेफ़ाक़ नहीं है। यह सौ releases के दौरान जमा हुए संस्थागत अनुशासन का नतीजा है, और इस release को किसी design document की तरह पढ़ना फ़ायदेमंद है।

दस साल में पका Never Type

1.100 का मुख्य फ़ीचर एक ऐसा type है जिसकी परिभाषा के हिसाब से कोई value नहीं होती। never type, जो ! लिखा जाता है, uninhabited type का मानक उदाहरण है: यह उन computations को दर्शाता है जो कभी किसी value पर resolve नहीं होतीं — जैसे infinite loop, return, panic!(), या std::process::exit की कॉल। Type theorists इसे बहुत पहले से जानते हैं; यह bottom type है, lambda calculus का ⊥, वह खाली set जो आपके type lattice के कोने में खड़ा रहता है। Haskell वाले इसे Void के नाम से जानते हैं। Rust 1.0 से पहले से इसके आसपास चक्कर लगा रहा था, और इसे लैंड करने में दस साल और पाँच असफल stabilization कोशिशें लग गईं।

इतना मुश्किल क्यों था? क्योंकि ! को किसी भी दूसरे type में coerce किया जा सकता है — यही इसकी ताक़त है — और हर coercion point वह जगह है जहाँ type inference, trait resolution और exhaustiveness checking को एक-दूसरे से सहमत होना पड़ता है। चूँकि diverge करने वाले match arm का type ! होता है, इसलिए यह कोड compile होता है:

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
}

let Ok(v) = res; वाली लाइन ही इनाम है: क्योंकि Err(!) कभी मौजूद नहीं हो सकता, compiler irrefutable pattern को स्वीकार कर लेता है, और unreachable!() की वह पूरी श्रेणी, जो defensive तरीक़े से लिखी जाती थी, ग़ायब हो जाती है। इसके साथ पुराना std::convert::Infallible enum अब ! के लिए type alias बन जाता है, इसलिए पिछले कुछ सालों में Infallible के हिसाब से लिखी गई हर API अपने-आप असली never type के साथ compatible हो जाती है। यह एकीकरण शुरू से योजना का हिस्सा था — और यही वजह थी कि stabilization बार-बार खिसकता रहा, क्योंकि alias बदलने के लिए 2024 से पहले वाले editions में never-type fallback बदलना पड़ता, जो तकनीकी रूप से एक breaking change है।

देखिए टीम ने उस break को कैसे संभाला, क्योंकि यही पूरी philosophy का छोटा रूप है। उन्होंने future-compatibility warnings पहले से भेजीं, ecosystem पर crater-testing की, और जो public crates प्रभावित होने वाले थे उनके लिए fixes खुद आगे बढ़कर भेजे। एक breaking change, जो कई release cycles में फैली रही, जिसका असर पहले से मापा और patch किया गया, इससे पहले कि ज़्यादातर users को कुछ पता चलता। इसकी तुलना उस आम industry तरीके से कीजिए जहाँ major version बढ़ाकर कंधे उचका दिए जाते हैं। मैंने पहले भी लिखा है कि soundness असल में Rust से किस बात की माँग करती है — never type की यह कहानी उसी प्रतिबद्धता का process-level रूप है। जब आपकी गारंटी यह है कि "safe code में undefined behavior नहीं हो सकता", तो शून्य inhabitants वाले type को भी अपनी जगह कमानी पड़ती है।

Custom Allocators को आख़िरकार स्थिर नींव मिली

लगभग उतने ही लंबे इंतज़ार के बाद: allocator_api के काम का मूल हिस्सा अब stable है। Allocator trait, Global, System और *_in constructors — Vec::new_in, Vec::with_capacity_in, Box::new_in, Box::from_raw_in — अब stable Rust पर उपलब्ध हैं। Library authors अब एक allocator बनाकर उसे standard collections को दे सकते हैं:

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);

अगर आपने सिर्फ़ application code लिखा है, तो यह plumbing जैसा लग सकता है। है भी — और systems languages की सफलता या असफलता इसी plumbing पर टिकती है। अब तक allocators बदलने का एक ही भोथरा तरीका था #[global_allocator]: पूरे process के लिए एक allocator। यह ठीक है जब आपको हर जगह jemalloc या mimalloc चाहिए (और performance का असली फ़ायदा भी है — jemalloc ने बड़े पैमाने पर अपनी साख कमाई है), लेकिन बेकार है जब आपको एक Vec चाहिए जो arena से बैक हो और request के अंत में एक झटके में मुक्त हो जाए, जबकि बाक़ी सब default heap से चले। Game engines, databases, कई RAM regions वाले embedded targets, kernel-adjacent code — इन सबको per-collection नियंत्रण चाहिए, और उन्हें यह सालों से चाहिए था।

Release में ही इस बात पर ज़ोर दिया गया है: यह "Allocators 1.0" project goal की स्पष्ट नींव है, और आगे और collections व pointer types आएँगे। Rust project अब आराम से कह सकता है: "यह stable core है; बाक़ी जानबूझकर अभी nightly में है।" यह क्रम — trait और design को stable करना, ecosystem को उस पर बनने देना, और surface area बाद में बढ़ाना — ठीक वही तरीका है जिससे आप किसी ऐसे API में फँसने से बचते हैं जिसे हमेशा सपोर्ट करना पड़े। C++ ने नब्बे के दशक में std::allocator के साथ उल्टा रास्ता लिया था, आधा-अधूरा भेजा और दशकों तक उसके मलबे के आसपास काम करता रहा। धैर्य सस्ता पड़ता है।

DropGuard: Go का defer, Rust के तरीके से

इस release का छुपा हुआ हीरो है std::mem::DropGuard। Rust का Drop trait पहले से गारंटी देता है कि value scope से बाहर जाते समय cleanup code चलेगा — return हो, ? हो, panic हो, कोई फ़र्क़ नहीं पड़ता। लेकिन सिर्फ़ exit पर closure चलाने के लिए एक नया type लिखना boilerplate है, जिससे ज़्यादातर लोग कुढ़ते रहे हैं। DropGuard एक value और एक closure को लपेटता है, value पर deref करता है ताकि आप उसे सामान्य रूप से इस्तेमाल कर सकें, और guard खत्म होने पर closure चलाता है। dismiss() method उसे निष्क्रिय कर देता है। इसका सबसे आम उपयोग transactional rollback है:

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(())
}

अगर यह Go के defer जैसा लगता है, तो है — लेकिन गारंटी कहाँ रहती है, इसमें एक अहम फ़र्क़ है। Go का defer function-scoped statement है: यह function return होने पर चलता है, और type system को दिखता नहीं। DropGuard एक value है। आप इसे move कर सकते हैं, store कर सकते हैं, दूसरे scope को दे सकते हैं, शर्त के अनुसार dismiss कर सकते हैं। इसकी जड़ें C++ RAII और Alexandrescu के पुराने ScopeGuard trick तक जाती हैं, जो modern C++ के शुरुआती दिनों में destructors और Dismiss() कॉल से वही काम करता था। Rust ने यह विचार ईजाद नहीं किया; उसने बीस साल पुराने C++ idiom को अपनाया, उसे ownership semantics दिए, और core में डाल दिया। अच्छी language evolution असल में ऐसे ही होती है — नवीनता से नहीं, बल्कि साबित patterns को standard vocabulary में शामिल करने से।

एक कलाबाज़ रस्सी पर घाटी पार करता हुआ, पीछे सुरक्षा रस्सी बंधी है
DropGuard वह बंधी हुई रस्सी है: तार पर जो भी हो, rollback चलेगा।

कुछ न होने की रचना: Zero-Sized Types सही ढंग से

निचले हिस्सों में छिपा एक function है जिसका नाम मुझे सच में पसंद है: std::mem::conjure_zst। Zero-sized types — unit structs, और PyO3 का Python<'py जैसे marker tokens — Rust की type-level programming में हर जगह हैं। अगर किसी inhabited type का size नहीं है, तो उसमें रखी जा सकने वाली value सिर्फ़ एक ही होती है, इसलिए उसे बनाना एक तरह से हमेशा "safe" है। लेकिन APIs अक्सर इन tokens के नकली न बनाए जा सकने पर निर्भर करती हैं: हवा से Python<'py बना देने से safe code दिखावा कर सकता था कि उसके पास GIL है। पहले लोग ZSTs को () के transmute या MaybeUninit के जादुई मंत्रों से बनाते थे, और हर तरीक़े के अलग-अलग निहितार्थ थे, जो अभी तय न हुई unsafe-code guidelines पर असर डालते थे। अब एक ही, साफ़ तौर पर unsafe लिखा गया तरीका है। यह छोटा सा function इसलिए है ताकि एक बड़े specification सवाल का एक, जाँचा जा सकने वाला जवाब हो। सादा, सावधान, सही — पूरी release एक API में।

Cargo के Dependency Cooldowns: टाइमर पर Supply Chain सुरक्षा

1.100 का सबसे अहम बदलाव शायद भाषा में है ही नहीं। Cargo अब min-publish-age के हिसाब से dependency resolution को सपोर्ट करता है — dependency cooldowns। इसके पीछे का विचार अनुभवजन्य है: malicious package versions आमतौर पर प्रकाशन के कुछ घंटों या दिनों के भीतर scanners या इंसानों द्वारा पकड़ ली जाती हैं। इसलिए बस उन versions को resolve करने से इनकार करें जो एक तय अवधि से नई हों:

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

इसके बाद cargo update नई releases को चुपचाप छोड़ देता है और बताता है कि उसने क्या रोका — clap 4.6.7 (available: 4.6.9, published 2 days ago)। जब आपको सच में कोई hot fix चाहिए, तो एक बार का environment variable override आपको उसे जानबूझकर खींचने देता है, और वह चुनाव Cargo.lock में दर्ज होता है, चुपचाप फैलता नहीं। यह दुर्लभ security control है जो लगभग कुछ नहीं लेता: आप कुछ दिनों की ताज़गी के बदले हर उस zero-day package attack के खिलाफ स्थायी quarantine पाते हैं जो जल्दी पकड़ लिया जाता है। दूसरे registries के साथ जो हुआ है, उसे देखते हुए — PyPI पर LiteLLM का compromise हाल ही में दिखाता है कि ज़हरीली release कितनी तेज़ी से फैलती है — cooldown ecosystem में सबसे सस्ता बीमा है। Release notes ईमानदारी से मानते हैं कि यह पूरी सुरक्षा नहीं है, और cargo install इसे पूरी तरह बायपास कर देता है। Quarantine support और संदिग्ध releases की automated detection अभी भी crates.io roadmap पर हैं। Defense in depth, एक-एक परत करके भेजी जा रही है।

Build Hygiene: Unused Dependencies और Cache Collisions

दो quality-of-life बदलाव ज़िक्र के लायक हैं, क्योंकि ये किसी भी Rust चर्चा की दो सबसे आम शिकायतों पर हमला करते हैं: compile time और disk usage। पहला, Cargo अब सीधे unused dependencies की रिपोर्ट करता है, और warning आपके Cargo.toml की ठीक उसी लाइन की ओर इशारा करती है। Rustc में unused_crate_dependencies lint काफ़ी समय से है, लेकिन Cargo के साथ यह गलत positives देता था, क्योंकि dependencies build targets के बीच साझा होती हैं — एक package में एक bin द्वारा इस्तेमाल होने वाली dep दूसरे के लिए unused दिखती थी। Cargo के पास वह global view है जो rustc के पास नहीं, इसलिए warning अब वहीं है जहाँ सच है। यह सभी संबंधित targets build करने पर लागू होती है, और यह manifest के लिए एक नए [lints.cargo] linting system का पहला सदस्य है।

दूसरा, build directory को फिर से व्यवस्थित किया गया। अलग-अलग build configurations — feature sets, profiles — अलग artifacts बनाते हैं, और एक configuration hash उन्हें अलग रखता है। यह hash platform की सीमाओं की वजह से हर जगह एक जैसा लागू नहीं हो रहा था, जिससे अतिरिक्त rebuilds, छूटे हुए rebuilds और आम उलझन होती थी, और अगर आप build directory को git worktrees के बीच साझा करते थे तो हालत और बुरी थी। अब hash filenames से निकलकर build step के हिसाब से व्यवस्थित directory structure में चला गया है। जब सब ठीक चलता है तो यह दिखता ही नहीं, और यही इसका मकसद है — और यह भविष्य में cache garbage collection और cross-workspace deduplication के लिए रास्ता खोलता है। अगर आपकी target/ directory कभी 90 gigabytes खा चुकी है और रोज़ cargo clean करना पड़ा है, तो आपकी राहत की नींव अभी रखी गई है। पूरा fix अभी यहाँ नहीं है, लेकिन भार उठाने वाला refactor आ चुका है।

एक विशाल गोदाम जहाँ crates व्यवस्थित कतारों में रखे हैं, एक कोने में रस्सी से घिरा quarantine क्षेत्र है
Cooldowns और cache hygiene: वे नीरस व्यवस्थाएँ जो package ecosystem को भरोसेमंद रखती हैं।

सौ releases हमें भाषा के विकास के बारे में क्या सिखाती हैं

स्थिरता बदलाव की अनुपस्थिति नहीं है। यह बदलाव को इस तरह क्रम में लाने का अनुशासन है कि आपकी roadmap की कीमत किसी का code न चुकाए।

इस release का आकार एक बार देखिए। एक type-theory का सुधार जिसमें दशक लगा। एक allocator trait जो जानबूझकर पूरी सतह के बजाय नींव के रूप में भेजा गया। एक scope-guard idiom जो कुछ users से भी पुराना है, आख़िरकार standardize हुआ। registry metadata और ईमानदार चेतावनियों पर बनी एक security सुविधा। Build-system के अंदरूनी हिस्से भविष्य के काम के लिए रास्ता खोलने को फिर से बनाए गए। इनमें से कोई भी चौंकाने वाला paradigm shift नहीं है, और फिर भी मिलकर यही हैं: एक ऐसी भाषा जो और गहरी होती जाती है, बिना आपके नीचे से बदले। यही शांत संचय Java की नीरस लेकिन लगातार प्रगति में दिखता है, एक और ecosystem जिसने समझ लिया कि बोरिंग होना भी एक फ़ीचर है।

जो चीज़ें यह संभव बनाती हैं, उन्हें किसी भी फ़ीचर जितना श्रेय मिलना चाहिए। छह-हफ़्ते वाला train model मतलब है कि कोई stabilization कभी आपातकाल नहीं बनता। Crater — जो लगभग पूरे public crate ecosystem को एक candidate compiler के साथ compile करता है — "क्या इससे किसी का कुछ टूटेगा?" को प्रार्थना से माप में बदल देता है। Editions एक opt-in migration path देते हैं, ताकि भाषा आपका code बदले बिना अपने defaults बदल सके। और named project goals की अपेक्षाकृत नई संस्था (Allocators 1.0, build directory layout, crates.io supply chain hardening) बहु-वर्षीय प्रयासों को सार्वजनिक रीढ़ देती है, ताकि never type जैसा फ़ीचर पाँच बार असफल हो और फिर भी उसके पास घर लौटने का तय रास्ता हो, न कि वह mailing list की बहस में मर जाए।

किसी platform, protocol या व्यापक रूप से इस्तेमाल होने वाली library को संभालने वाले के लिए यहाँ एक सबक है। Users आपकी roadmap का अनुभव नहीं करते; वे आपके diffs का अनुभव करते हैं। never type का 1.35 के बजाय 1.100 में आना धीमेपन की कहानी नहीं है — यह इस बात की कहानी है कि जब कोई project दशक भर "जब दिखेगा तब देखेंगे" को स्वीकार्य जवाब माने तो क्या होता है। ज़्यादातर software संस्थाएँ इतना धैर्य नहीं रख सकतीं, और ईमानदारी से कहें तो ज़्यादातर को इसकी ज़रूरत भी नहीं होती। लेकिन अगर आप ऐसी चीज़ बना रहे हैं जिस पर दूसरे लोग निर्भर रहेंगे, तो गणित पलट जाता है: आपके users का भरोसा ब्याज की तरह बढ़ता है, और उसे कमाने का एक ही तरीका है — सौ releases जहाँ कुछ न टूटे। Rust 1.100 एक बड़ी release है। असली कहानी यह है कि आप इसे release notes पढ़े बिना भी इंस्टॉल कर सकते हैं।