जंग 1.27 रिलीज

रस्ट डेवलपमेंट टीम, रूस्ट के एक नए संस्करण: 1.27.0 की रिलीज की घोषणा करते हुए प्रसन्न है। रस्ट एक सिस्टम प्रोग्रामिंग भाषा है जिसका उद्देश्य सुरक्षा, गति और समानांतर कोड निष्पादन है।

यदि आपके पास जंग का उपयोग करके स्थापित जंग का पिछला संस्करण है, तो जंग को संस्करण 1.27.0 में अपग्रेड करने के लिए आपको बस करने की आवश्यकता है:

$ rustup update stable 

यदि आपने पहले से रस्टअप स्थापित नहीं किया है, तो आप इसे हमारी वेबसाइट के संबंधित पृष्ठ से स्थापित कर सकते हैं। Rust 1.27.0 के लिए विस्तृत रिलीज़ नोट्स GitHub पर उपलब्ध हैं।

हम इस पर भी आपका ध्यान आकर्षित करना चाहते हैं: संस्करण 1.27.0 के जारी होने से पहले, हमने संस्करण 1.26.0 में पेश किए गए match मैपिंग में एक त्रुटि की खोज की, जिससे गैर-सही व्यवहार हो सकता है। चूंकि यह बहुत देर से खोजा गया था, पहले से ही इस संस्करण को जारी करने की प्रक्रिया में, हालांकि यह संस्करण 1.26.0 के बाद से मौजूद है, हमने रूटीन को नहीं तोड़ने और एक निश्चित संस्करण 1.27.1 तैयार करने का फैसला किया, जिसे निकट भविष्य में जारी किया जाएगा। और इसके अलावा, यदि आवश्यक हो, तो संस्करण 1.26.3। विवरण संबंधित रिलीज नोट्स में पाया जा सकता है।

स्थिर संस्करण 1.27.0 में क्या शामिल है

इस समस्या में, दो बड़े और लंबे समय से प्रतीक्षित भाषा सुधार सामने आते हैं। लेकिन पहले, प्रलेखन पर एक छोटी सी टिप्पणी: खोज अब रस्ट लाइब्रेरी में सभी पुस्तकों में उपलब्ध है! उदाहरण के लिए, आप "रस्ट प्रोग्रामिंग लैंग्वेज" पुस्तक में "उधार" पा सकते हैं । हमें उम्मीद है कि इससे आपको आवश्यक जानकारी खोजने में आसानी होगी। इसके अलावा, सरसराहट के बारे में एक नई किताब सामने आई है । यह पुस्तक बताती है कि सीधे rustc का उपयोग कैसे करें, और अन्य उपयोगी जानकारी कैसे प्राप्त करें, जैसे सभी स्थैतिक जाँच की सूची।

SIMD

तो, अब महत्वपूर्ण के बारे में: अब से, SIMD का उपयोग करने की बुनियादी सुविधाएँ जंग में उपलब्ध हैं! SIMD का अर्थ है "एकल निर्देश, एकाधिक डेटा स्ट्रीम" (एकल निर्देश, एकाधिक डेटा)। फ़ंक्शन पर विचार करें:

 pub fn foo(a: &[u8], b: &[u8], c: &mut [u8]) { for ((a, b), c) in a.iter().zip(b).zip(c) { *c = *a + *b; } } 

यहां हम दो पूर्णांक स्लाइस लेते हैं, उनके तत्वों को जोड़ते हैं और परिणाम को तीसरे स्लाइस में डालते हैं। उपरोक्त कोड ऐसा करने का सबसे आसान तरीका दर्शाता है: आपको तत्वों के पूरे सेट के माध्यम से जाने की जरूरत है, उन्हें एक साथ रखें और परिणाम को बचाएं। हालांकि, संकलक अक्सर एक बेहतर समाधान पाते हैं। LLVM अक्सर "स्वचालित रूप से समान कोड" को सदिश करता है, जहां इस तरह के जटिल शब्द का अर्थ है "SIMD का उपयोग करता है।" कल्पना कीजिए कि स्लाइस a और b 16 तत्व लंबे हैं, दोनों। प्रत्येक तत्व u8 , जिसका अर्थ है कि स्लाइस में प्रत्येक के 128 बिट डेटा होंगे। SIMD का उपयोग करके, हम 128-बिट रजिस्टरों में दोनों स्लाइस a और b रख सकते हैं, उन्हें एक निर्देश के साथ जोड़ सकते हैं, और फिर परिणामी 128 बिट्स को c कॉपी कर सकते हैं। यह बहुत तेजी से काम करेगा!

इस तथ्य के बावजूद कि रस्ट का स्थिर संस्करण हमेशा स्वचालित वेक्टराइजेशन का लाभ उठाने में सक्षम रहा है, कभी-कभी कंपाइलर बस इतना समझदार नहीं होता है कि वह इस मामले में लागू हो सके। इसके अलावा, सभी सीपीयू इन सुविधाओं का समर्थन नहीं करते हैं। इसलिए, एलएलवीएम हमेशा उनका उपयोग नहीं कर सकता है, क्योंकि आपका प्रोग्राम विभिन्न हार्डवेयर प्लेटफार्मों पर चल सकता है। इसलिए, रुस्त 1.27 में, std::arch मॉड्यूल के अतिरिक्त के साथ, इस प्रकार के निर्देशों का सीधे उपयोग करना संभव हो गया, अर्थात अब हम केवल बुद्धिमान संकलन पर भरोसा करने के लिए बाध्य नहीं हैं। इसके अतिरिक्त, हमारे पास विभिन्न मानदंडों के आधार पर एक विशिष्ट कार्यान्वयन चुनने का अवसर है। उदाहरण के लिए:

 #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "avx2"))] fn foo() { #[cfg(target_arch = "x86")] use std::arch::x86::_mm256_add_epi64; #[cfg(target_arch = "x86_64")] use std::arch::x86_64::_mm256_add_epi64; unsafe { _mm256_add_epi64(...); } } 

यहाँ हम cfg झंडे का उपयोग लक्ष्य प्लेटफ़ॉर्म के आधार पर कोड के सही संस्करण का चयन करने के लिए करते हैं: x86 पर इसके स्वयं के संस्करण का उपयोग किया जाएगा, और x86_64 अपने स्वयं के संस्करण पर। हम रनटाइम पर भी चयन कर सकते हैं:

 fn foo() { #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { if is_x86_feature_detected!("avx2") { return unsafe { foo_avx2() }; } } foo_fallback(); } 

यहां हमारे पास फ़ंक्शन के दो संस्करण हैं: एक AVX2 का उपयोग करता है - एक विशिष्ट प्रकार का SIMD जो आपको 256-बिट संचालन करने की अनुमति देता है। मैक्रो is_x86_feature_detected! एक कोड उत्पन्न करेगा जो जांचता है कि प्रोसेसर foo_avx2 का समर्थन करता है या नहीं, और यदि ऐसा है, तो फ़ंक्शन foo_avx2 कहा जाएगा। यदि नहीं, तो हम AVX, foo_fallback बिना कार्यान्वयन का सहारा foo_fallback । तो हमारा कोड AVX2 का समर्थन करने वाले प्रोसेसर पर बहुत तेजी से काम करेगा, लेकिन यह अन्य प्रोसेसर पर भी काम करेगा, यद्यपि यह धीरे-धीरे अधिक होता है।

यह सब थोड़ा निम्न स्तर और असुविधाजनक लग रहा है - हाँ, यह है! std::arch इस तरह की चीजों के लिए आदिम हैं। हमें उम्मीद है कि भविष्य में हम अभी भी std::simd को उच्च-स्तरीय क्षमताओं के साथ स्थिर करेंगे। लेकिन बुनियादी SIMD क्षमताओं का उद्भव अब आपको विभिन्न पुस्तकालयों के लिए उच्च-स्तरीय समर्थन के साथ प्रयोग करने की अनुमति देता है। उदाहरण के लिए, तेज पैकेज देखें। यहाँ SIMD के बिना कोड का एक टुकड़ा है:

 let lots_of_3s = (&[-123.456f32; 128][..]).iter() .map(|v| { 9.0 * v.abs().sqrt().sqrt().recip().ceil().sqrt() - 4.0 - 2.0 }) .collect::<Vec<f32>>(); 

इस कोड में faster SIMD का उपयोग करने के लिए, आपको इसे इस तरह बदलना होगा:

 let lots_of_3s = (&[-123.456f32; 128][..]).simd_iter() .simd_map(f32s(0.0), |v| { f32s(9.0) * v.abs().sqrt().rsqrt().ceil().sqrt() - f32s(4.0) - f32s(2.0) }) .scalar_collect(); 

यह लगभग समान दिखता है: iter बजाय simd_map , simd_map बजाय f32s(2.0) , f32s(2.0) बजाय f32s(2.0) । लेकिन अंत में, आपको अपने कोड का एक सिमड-प्रमाणित संस्करण मिलता है।

इसके अलावा, आप कभी भी इसे स्वयं नहीं लिख सकते हैं, लेकिन हमेशा की तरह, आपके द्वारा निर्भर पुस्तकालयों में ऐसा किया जा सकता है। उदाहरण के लिए, regex में पहले ही समर्थन जोड़ा जा चुका है , और इसके नए संस्करण में आपको कुछ भी करने की आवश्यकता के बिना SIMD त्वरण होगा!

dyn Trait

अंत में, हमने Rust में विशेषता वस्तुओं के आरंभिक रूप से चयनित वाक्यविन्यास पर खेद व्यक्त किया। जैसा कि आपको याद है, Foo लिए, आप इस तरह एक विशेषता वस्तु को परिभाषित कर सकते हैं:

 Box<Foo> 

हालांकि, अगर Foo एक संरचना थी, तो इसका मतलब होगा कि संरचना को Box<T> अंदर Box<T> । भाषा का विकास करते समय, हमने सोचा कि ऐसी समानताएं एक अच्छा विचार होगा, लेकिन अनुभव से पता चला है कि इससे भ्रम पैदा होता है। और यह सिर्फ Box<Trait> : impl SomeTrait for SomeOtherTrait भी औपचारिक रूप से सही सिंटैक्स है, लेकिन आपको लगभग हमेशा लिखना होगा impl<T> SomeTrait for T where T: SomeOtherTrait इसके बजाय। यह impl SomeTrait साथ ऐसा ही है, जो दिखता है कि यह विधियों को जोड़ता है या प्रकार के लिए एक संभावित डिफ़ॉल्ट कार्यान्वयन है, लेकिन वास्तव में यह प्रकार के ऑब्जेक्ट में अपने स्वयं के तरीकों को जोड़ता है। अंत में, हाल ही में जोड़े गए impl Trait सिंटैक्स की तुलना में, impl Trait सिंटैक्स उपयोग करने में कम और बेहतर लगता है, लेकिन वास्तव में यह हमेशा सच नहीं होता है।

इसलिए, रस्ट 1.27 में, हमने नए dyn Trait सिंटैक्स को स्थिर किया। अब इस तरह दिखते हैं ऑब्जेक्ट:

 //  =>  Box<Foo> => Box<dyn Foo> &Foo => &dyn Foo &mut Foo => &mut dyn Foo 

इसी तरह अन्य सूचक प्रकारों के लिए: Arc<Foo> अब Arc<dyn Foo> , आदि है। पिछड़ी संगतता आवश्यकता के कारण, हम पुराने सिंटैक्स को हटा नहीं सकते हैं, लेकिन हमने एक bare-trait-object स्थैतिक चेक को जोड़ा है, जो डिफ़ॉल्ट रूप से पुराने सिंटैक्स को हल करता है। यदि आप इसे प्रतिबंधित करना चाहते हैं, तो आप इस चेक को सक्रिय कर सकते हैं। हमने सोचा कि चेक डिफ़ॉल्ट रूप से चालू हो जाने के बाद, अब बहुत सारी चेतावनियाँ प्रदर्शित की जाएंगी।

वैसे, हम एक उपकरण पर काम कर रहे हैं, जिसे rustfix कहा जाता है, जो स्वचालित रूप से आपके कोड को नए मुहावरों में अपडेट कर सकता है। वह इसके लिए समान स्टेटिक चेक का उपयोग करेगा। भविष्य की घोषणाओं में rustfix की घोषणाओं के लिए बने रहें।

#[must_use] कार्यों के लिए

निष्कर्ष में, विशेषता #[must_use] के प्रभाव का विस्तार #[must_use] गया है: अब इसका उपयोग कार्यों के लिए किया जा सकता है ।

पहले, यह केवल प्रकारों पर लागू होता था, जैसे कि Result <T, E> । लेकिन अब आप यह कर सकते हैं:

 #[must_use] fn double(x: i32) -> i32 { 2 * x } fn main() { double(4); // warning: unused return value of `double` which must be used let _ = double(4); // (no warning) } 

इस विशेषता के साथ, हमने मानक पुस्तकालय में भी थोड़ा सुधार किया है : Clone::clone , Iterator::collect और ToOwned::to_owned चेतावनी देते हैं यदि आप उनके रिटर्न मानों का उपयोग नहीं करते हैं, जो आपको महंगे संचालन को नोटिस करने में मदद करेगा जिनके परिणाम आप गलती से अनदेखा कर देते हैं।

अधिक जानकारी के लिए रिलीज़ नोट देखें।

पुस्तकालय स्थिरीकरण

इस रिलीज में निम्नलिखित नए एपीआई को स्थिर किया गया है:

• DoubleEndedIterator::rfind
• DoubleEndedIterator::rfold
• DoubleEndedIterator::try_rfold
• Duration::from_micros
• Duration::from_nanos
• Duration::subsec_micros
• Duration::subsec_millis
• HashMap::remove_entry
• Iterator::try_fold
• Iterator::try_for_each
• NonNull::cast
• Option::filter
• String::replace_range
• Take::set_limit
• slice::rsplit_mut
• slice::rsplit
• slice::swap_with_slice
• hint::unreachable_unchecked
• os::unix::process::parent_id
• ptr::swap_nonoverlapping
• process::id

अधिक जानकारी के लिए रिलीज़ नोट देखें।

कार्गो संवर्द्धन

इस रिलीज में कार्गो को दो मामूली सुधार मिले हैं। सबसे पहले, एक --target-dir , जिसका उपयोग लक्ष्य निष्पादन निर्देशिका को बदलने के लिए किया जा सकता है।

इसके अतिरिक्त, कार्गो के लक्ष्यों को संभालने के तरीके को अंतिम रूप दिया गया है। कार्गो आपके प्रोजेक्ट के भीतर परीक्षणों, उदाहरणों और निष्पादन योग्यताओं का पता लगाने की कोशिश करता है। हालांकि, कभी-कभी स्पष्ट कॉन्फ़िगरेशन की आवश्यकता होती है। लेकिन प्रारंभिक कार्यान्वयन में, यह समस्याग्रस्त था। मान लें कि आपके पास दो उदाहरण हैं, और कार्गो दोनों उनका पता लगाते हैं। आप उनमें से किसी एक को कॉन्फ़िगर करना चाहते हैं, जिसके लिए आप उदाहरण के मापदंडों को निर्दिष्ट करने के लिए Cargo.toml [[example]] Cargo.toml हैं। वर्तमान में, कार्गो देखेगा कि आपने उदाहरण को स्पष्ट रूप से परिभाषित किया है, और इसलिए स्वचालित रूप से दूसरों का पता लगाने की कोशिश नहीं करेंगे। यह थोड़ा परेशान करने वाला है।

इसलिए, हमने 'auto'- Cargo.toml । हम इस व्यवहार को उन परियोजनाओं के संभावित टूटने के बिना ठीक नहीं कर सकते जो इस पर अनजाने में भरोसा करते हैं। इसलिए, यदि आप कुछ लक्ष्यों को कॉन्फ़िगर करना चाहते हैं, लेकिन सभी नहीं, तो आप [package] अनुभाग में true करने के लिए autoexamples कुंजी सेट कर सकते हैं।

अधिक जानकारी के लिए रिलीज़ नोट देखें।

डेवलपर्स 1.27.0

रूस्त 1.27 के विकास में बहुत से लोगों ने भाग लिया। हम आप में से प्रत्येक के बिना काम पूरा नहीं कर सकते थे।

धन्यवाद!

एक अनुवादक से: मैं खंडहर समुदाय के सदस्यों और व्यक्तिगत रूप से अनुवाद और प्रूफरीडिंग के साथ उनकी मदद के लिए व्यक्तिगत रूप से आभार व्यक्त करता हूं