जंग 1.32 रिलीज

रस्ट डेवलपमेंट टीम, रुस्ट के एक नए संस्करण, 1.32.0 की रिलीज की घोषणा करते हुए प्रसन्न है। रस्ट एक प्रोग्रामिंग भाषा है जो सभी को विश्वसनीय और कुशल सॉफ्टवेयर बनाने में सक्षम बनाती है।

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

 $ rustup update stable 

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

एक rustup टिप्पणी: rustup में कई नए rustup रिलीज rustup ! rustup को अपडेट करने के लिए, rustup self update ।

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

जंग 1.32.0 ने कई जीवन-वर्धक सुधार प्राप्त किए, डिफ़ॉल्ट मेमोरी एलोकेटर को बदल दिया, और अधिक कार्यों को स्थिर बना दिया। नीचे दिए गए इन परिवर्तनों के बारे में पढ़ें या रिलीज़ नोटों में और देखें।

डीबीजी मैक्रो

आइए एक जीवन-सुधार के साथ शुरू करें। क्या आप प्रिंट डिबगिंग का उपयोग करते हैं? यदि हां, और आप कोड पर काम करते समय कुछ मूल्य प्रिंट करना चाहते हैं, तो आप ऐसा करने के लिए मजबूर हैं:

 let x = 5; println!("{:?}", x); //    println!("{:#?}", x); 

यह विकास को धीमा करने वाली सबसे बड़ी बाधा नहीं है, लेकिन यह केवल x मूल्य के आउटपुट को डीबग करने में बहुत अधिक प्रयास करता है। इसके अलावा, यहां संदर्भ को ध्यान में नहीं रखा गया है। यदि आपके पास कई ऐसे println! s, यह निर्धारित करना मुश्किल हो जाता है कि आउटपुट का संदर्भ क्या है, जब तक कि आप स्वयं प्रत्येक कॉल में संदर्भ जानकारी नहीं जोड़ते हैं, जिसके लिए और भी अधिक काम करने की आवश्यकता होती है।

इन उद्देश्यों के लिए, रस्ट 1.32.0 में हमने एक नया मैक्रो dbg जोड़ा! :

 fn main() { let x = 5; dbg!(x); } 

इस कार्यक्रम को शुरू करने के बाद, आप देखेंगे:

 [src/main.rs:4] x = 5 

चर नाम और उसके मूल्य के साथ, फ़ाइल नाम और लाइन नंबर जहां dbg! कॉल किया गया था प्रदर्शित किया जाएगा dbg! ।

इसके अलावा, println! मानक आउटपुट पर प्रिंट करता है, इसलिए eprintln! का उपयोग करना बेहतर है eprintln! मानक त्रुटि स्ट्रीम पर प्रिंट करने के लिए। dbg! Stderr करने के लिए आउटपुट, और ठीक है।

यह मुश्किल मामलों में भी काम करता है। तथ्यात्मक कार्यान्वयन के एक उदाहरण पर विचार करें:

 fn factorial(n: u32) -> u32 { if n <= 1 { n } else { n * factorial(n - 1) } } 

इसे डीबग करने के लिए, हम eprintln! उपयोग कर सकते हैं eprintln! :

 fn factorial(n: u32) -> u32 { eprintln!("n: {}", n); if n <= 1 { eprintln!("n <= 1"); n } else { let n = n * factorial(n - 1); eprintln!("n: {}", n); n } } 

हम प्रत्येक पुनरावृत्ति पर n आउटपुट करना चाहते हैं और प्रत्येक शाखाओं का संदर्भ देखना चाहते हैं। factorial(4) उत्पादन होगा:

 n: 4 n: 3 n: 2 n: 1 n <= 1 n: 2 n: 6 n: 24 

यह स्वीकार्य है, लेकिन विशेष रूप से अच्छा नहीं है। शायद हम निष्कर्ष को स्पष्ट करने के लिए संदर्भ जानकारी के उत्पादन में सुधार करने के लिए काम कर सकते हैं। लेकिन फिर, हमारे कोड को डीबग करने के बजाय, हम डीबगिंग कोड में सुधार करेंगे।

dbg! का उपयोग करके उसी उदाहरण पर विचार करें dbg! :

 fn factorial(n: u32) -> u32 { if dbg!(n <= 1) { dbg!(1) } else { dbg!(n * factorial(n - 1)) } } 

हम बस एक मैक्रो को प्रत्येक अभिव्यक्ति के साथ लपेटते हैं जिसे हम आउटपुट करना चाहते हैं। नतीजतन, हम प्राप्त करते हैं:

 [src/main.rs:3] n <= 1 = false [src/main.rs:3] n <= 1 = false [src/main.rs:3] n <= 1 = false [src/main.rs:3] n <= 1 = true [src/main.rs:4] 1 = 1 [src/main.rs:5] n * factorial(n - 1) = 2 [src/main.rs:5] n * factorial(n - 1) = 6 [src/main.rs:5] n * factorial(n - 1) = 24 [src/main.rs:11] factorial(4) = 24 

चूंकि मैक्रो dbg! डीबग मान स्वयं लौटाता है, eprintln! विपरीत eprintln! , जो देता है () , तो हमें अपने कोड की संरचना में कोई बदलाव करने की आवश्यकता नहीं है। इसके अतिरिक्त, हमें बहुत अधिक उपयोगी निष्कर्ष मिलता है।

हमने ऐसे छोटे मैक्रो पर बहुत ध्यान दिया, क्योंकि हमें उम्मीद है कि यह आपकी डिबगिंग प्रक्रिया को सरल करेगा। बेशक, हम भी gdb और कंपनी के समर्थन पर काम करना जारी रखते हैं

jemalloc हटा दिया गया jemalloc

एक बार, रुस्त के पास एरलंग के समान एक बड़ा रनटाइम था। उसके लिए, सिस्टम एलोकेटर के बजाय जेमलॉक को चुना गया था, क्योंकि यह अक्सर अधिक उत्पादक होता था। धीरे-धीरे, हमने अधिक से अधिक रनटाइम से छुटकारा पा लिया और अंत में, लगभग सभी को हटा दिया गया, लेकिन जेमलॉक बना रहा। हमारे पास कस्टम आवंटनकर्ता चुनने का कोई तरीका नहीं था, और इसलिए हम पूरी तरह से जेमलॉक को हटा नहीं सकते थे, ताकि उन लोगों को नुकसान न पहुंचे, जिन्हें इसकी आवश्यकता थी।

इसके अलावा, यह दावा कि jemalloc हमेशा डिफ़ॉल्ट jemalloc था, मुख्य रूप से यूनिक्स दुनिया से संबंधित था, क्योंकि यह केवल कुछ प्लेटफार्मों पर डिफ़ॉल्ट रूप से था। विशेष रूप से, विंडोज पर MSVC का लक्ष्य लंबे समय से एक सिस्टम आवंटनकर्ता का उपयोग कर रहा है।

अंत में, हालांकि जेमलॉक में आमतौर पर अच्छा प्रदर्शन होता है, यह हमेशा ऐसा नहीं होता है। इसके अलावा, यह प्रत्येक निष्पादन योग्य में लगभग 300 किलोबाइट जोड़ता है। इसके अलावा, हमने जैमलॉक के साथ कई अन्य समस्याओं को संचित किया है। सामान्य तौर पर, यह अजीब है कि सिस्टम भाषा डिफ़ॉल्ट रूप से सिस्टम एलोकेटर का उपयोग नहीं करती है।

इन कारणों के लिए, जैसे ही रस्ट 1.28 ने वैश्विक आवंटनकर्ता चुनने का एक तरीका प्रदान किया , हमने डिफ़ॉल्ट सिस्टम jemalloc पर स्विच करने और बाह्य पुस्तकालय के रूप में jemalloc प्रदान करने की योजना शुरू की। 1.32 रुस्ट में, हमने अंततः यह काम पूरा कर लिया है, और अब डिफ़ॉल्ट रूप से आपका प्रोग्राम सिस्टम एलोकेटर का उपयोग करेगा।

यदि आप जेमलॉक का उपयोग जारी रखना चाहते हैं, तो जैमलोकोटर लाइब्रेरी का उपयोग करें । ऐसा करने के लिए, Cargo.toml में निर्दिष्ट करें:

 jemallocator = "0.1.8" 

और अपने प्रोजेक्ट की रूट फाइल में:

 #[global_allocator] static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc; 

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

अंतिम मॉड्यूल प्रणाली में सुधार

पिछले दो रिलीज में, हमने मॉड्यूल सिस्टम में कई सुधारों के बारे में बात की। 1.32.0 और 2018 संस्करण में, हमने नवीनतम परिवर्तन जोड़ा। इसे "वर्दी पथ" कहा जाता है और आपको अन्य रास्तों की तरह ही आयात पथों के साथ काम करने की अनुमति देता है, जो पहले गलत तरीके से काम करता था। उदाहरण के लिए:

 enum Color { Red, Green, Blue } use Color::*; 

इस कोड को पहले संकलित नहीं किया गया है, क्योंकि use में आने वाले रास्तों को super , self या crate साथ शुरू करना चाहिए था। अब, संगत पथों का समर्थन करने वाले कंपाइलर के लिए धन्यवाद, यह कोड काम करेगा और वही करेगा जो आप उम्मीद करते हैं: ऊपर परिभाषित Color एनुमर के आयातकों को आयात करना।

यह परिवर्तन मॉड्यूल सिस्टम के हमारे संशोधन को पूरा करता है। हमें उम्मीद है कि आप सरलीकृत प्रणाली का उपयोग करके आनंद लेंगे!

मैक्रो एन्हांसमेंट

जंग 1.32.0 ने कई मैक्रो एन्हांसमेंट जारी किए हैं। सबसे पहले, एक नया शाब्दिक टुकड़ा निर्दिष्ट किया गया था:

 macro_rules! m { ($lt:literal) => {}; } fn main() { m!("some string literal"); } 

literal टुकड़ा किसी भी प्रकार के literal से मैप किया जाता है: स्ट्रिंग, संख्यात्मक और चरित्र।

2018 macro_rules क्या आप macro_rules उपयोग कर सकते हैं ? :

 macro_rules! bar { ($(a)?) => {} } 

के साथ टुकड़ा ? एक शून्य या एक घटना का मिलान किया जाएगा, बस एक खंड के रूप में * पहले से ही "शून्य या अधिक" घटनाओं से मेल खाता है, और + , एक या अधिक घटनाओं के साथ।

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

dbg! , जो हमने पहले ही ऊपर वर्णित किया है, मानक पुस्तकालय के लिए एक महत्वपूर्ण अतिरिक्त बन गया है। इसके अलावा, 19 कार्यों को स्थिर बनाया गया था और सभी संख्यात्मक आदिम प्रकारों को एक बाइट सरणी में रूपांतरण फ़ंक्शन प्राप्त हुए और इसके विपरीत निर्दिष्ट बाइट ऑर्डर के साथ। to_<endian>_bytes और from_<endian>_bytes , जहाँ <endian> from_<endian>_bytes <endian> है: के नाम के साथ छह कार्य हैं:

• ne - देशी आदेश (देशी एंडियननेस)
• le - जूनियर से सीनियर (थोड़ा एंडियन) का आदेश
• be - सबसे पुराने से सबसे कम उम्र के लिए ऑर्डर (बड़ा एंडियन)

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

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

कार्गो ने कार्गो चेक कमांड के लिए उर्फ कार्गो सी प्राप्त किया, और अब उपयोगकर्ता नाम को रिपॉजिटरी यूआरएल में उपयोग करने की अनुमति देता है ।

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

डेवलपर्स 1.32.0

बहुत सारे लोगों ने मिलकर 1.32.0 रूस्ट बनाया। हम आप में से प्रत्येक के बिना काम पूरा नहीं कर सकते थे। धन्यवाद!

एक अनुवादक से: मैं रस्टीक्रेट समुदाय के सदस्यों और व्यक्तिगत रूप से @dashadee और अनुवाद और प्रूफरीडिंग के साथ उनकी मदद के लिए ozkriff के लिए विशेष धन्यवाद व्यक्त करता हूं।