जंग 1.30 रिलीज

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

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

 $ rustup update stable 

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

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

रस्ट 1.30 कई महत्वपूर्ण नवाचारों के साथ एक उत्कृष्ट रिलीज है। लेकिन सोमवार को, आधिकारिक ब्लॉग को रस्ट 1.31 के बीटा संस्करण की जांच करने के लिए एक अनुरोध प्रकाशित किया जाएगा, जो कि "रस्ट 2018" की पहली रिलीज होगी। इसके बारे में अधिक जानकारी आपको हमारे पिछले प्रकाशन "व्हाट रस्ट 2018" में मिलेगी।

प्रक्रियात्मक मैक्रोज़

1.15 रस्ट में वापस , हमने "कस्टम व्युत्पन्न मैक्रोज़" को परिभाषित करने की क्षमता को जोड़ा। उदाहरण के लिए, serde_derive का उपयोग serde_derive , आप घोषणा कर सकते हैं:

 #[derive(Serialize, Deserialize, Debug)] struct Pet { name: String, } 

और Pet को JSON में कनवर्ट करें और serde_json का उपयोग करके संरचना में वापस serde_json । यह serde_derive में प्रक्रियात्मक मैक्रो का उपयोग करके Serialize और serde_derive Deserialize के स्वत: प्रवेश के लिए संभव है।

रस्ट 1.30 प्रक्रियात्मक मैक्रोज़ की कार्यक्षमता को दो अन्य प्रकार के मैक्रोज़ को परिभाषित करने की क्षमता को जोड़कर फैलता है: "प्रक्रियात्मक मैक्रोज़" और "कार्यात्मक प्रक्रियात्मक मैक्रोज़"।

विशेषता मैक्रोज़ स्वचालित आउटपुट के लिए मैक्रो को प्राप्त करने के समान हैं, लेकिन केवल #[derive] विशेषता के लिए कोड उत्पन्न करने के बजाय, वे उपयोगकर्ताओं को अपनी नई विशेषताओं को बनाने की अनुमति देते हैं। यह उन्हें और अधिक लचीला बनाता है: व्युत्पन्न मैक्रोज़ केवल संरचनाओं और गणनाओं के लिए काम करते हैं, लेकिन विशेषताओं को अन्य वस्तुओं पर लागू किया जा सकता है, जैसे कि फ़ंक्शन। उदाहरण के लिए, विशेषता मैक्रोज़ आपको वेब फ्रेमवर्क का उपयोग करते समय निम्नलिखित करने की अनुमति देगा:

 #[route(GET, "/")] fn index() { 

यह विशेषता #[route] को फ्रेमवर्क में ही एक प्रक्रियात्मक मैक्रो के रूप में परिभाषित किया जाएगा। उनके हस्ताक्षर इस तरह होंगे:

 #[proc_macro_attribute] pub fn route(attr: TokenStream, item: TokenStream) -> TokenStream { 

यहां हमारे पास TokenStream दो इनपुट पैरामीटर हैं: पहला है खुद की विशेषता के लिए सामग्री, यानी ये GET, "/" पैरामीटर हैं। दूसरा उस वस्तु का निकाय है जिसके लिए विशेषता लागू की जाती है। हमारे मामले में, यह fn index() {} और बाकी का फंक्शन है।

कार्यात्मक मैक्रोज़ मैक्रोज़ को परिभाषित करता है जिसका उपयोग फ़ंक्शन कॉल की तरह दिखता है। उदाहरण के लिए, sql! :

 let sql = sql!(SELECT * FROM posts WHERE id=1); 

यह मैक्रो अपने अंदर SQL अभिव्यक्तियों को पार्स करेगा और उन्हें सिंटेक्टिक शुद्धता के लिए जाँच करेगा। एक समान मैक्रो को निम्नानुसार घोषित किया जाना चाहिए:

 #[proc_macro] pub fn sql(input: TokenStream) -> TokenStream { 

यह व्युत्पन्न मैक्रो के हस्ताक्षर के समान है: हम टोकन प्राप्त करते हैं जो कोष्ठक के अंदर होते हैं और उनके द्वारा उत्पन्न कोड वापस करते हैं।

मैक्रोज़ और use

अब आप उपयोग कीवर्ड का उपयोग करके मैक्रोज़ को दायरे में आयात कर सकते हैं । उदाहरण के लिए, serde-json पैकेज से serde-json मैक्रो का उपयोग करने के लिए, प्रविष्टि का उपयोग किया जाता है:

 #[macro_use] extern crate serde_json; let john = json!({ "name": "John Doe", "age": 43, "phones": [ "+44 1234567", "+44 2345678" ] }); 

और अब आपको लिखना होगा:

 extern crate serde_json; use serde_json::json; let john = json!({ "name": "John Doe", "age": 43, "phones": [ "+44 1234567", "+44 2345678" ] }); 

यहां, मैक्रो को अन्य तत्वों के रूप में आयात किया जाता है, इसलिए macro_use एनोटेशन का उपयोग करने की कोई आवश्यकता नहीं है।

अंत में, proc_macro पैकेज को स्थिर किया जाता है , जो प्रक्रियात्मक मैक्रोज़ लिखने के लिए आवश्यक API प्रदान करता है। इसने एपीआई को संभालने में त्रुटि में भी काफी सुधार किया, और syn और quote जैसे पैकेज पहले से ही इसका उपयोग करते हैं। उदाहरण के लिए, पहले:

 #[derive(Serialize)] struct Demo { ok: String, bad: std::thread::Thread, } 

इस त्रुटि के कारण:

 error[E0277]: the trait bound `std::thread::Thread: _IMPL_SERIALIZE_FOR_Demo::_serde::Serialize` is not satisfied --> src/main.rs:3:10 | 3 | #[derive(Serialize)] | ^^^^^^^^^ the trait `_IMPL_SERIALIZE_FOR_Demo::_serde::Serialize` is not implemented for `std::thread::Thread` 

अब यह जारी किया जाएगा:

 error[E0277]: the trait bound `std::thread::Thread: serde::Serialize` is not satisfied --> src/main.rs:7:5 | 7 | bad: std::thread::Thread, | ^^^ the trait `serde::Serialize` is not implemented for `std::thread::Thread` 

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

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

मैक्रोज़ के लिए उपरोक्त परिवर्तन के अलावा, उपयोग करने के लिए दो नए सुधार use । सबसे पहले, बाहरी पैकेज अब प्रस्तावना में जोड़े जाते हैं , अर्थात् :

 //  let json = ::serde_json::from_str("..."); //  let json = serde_json::from_str("..."); 

पकड़ यह है कि रस्ट मॉड्यूल प्रणाली की विशेषताओं के कारण पुरानी शैली की हमेशा जरूरत नहीं थी:

 extern crate serde_json; fn main() { //   ;     ,  `serde_json` //     let json = serde_json::from_str("..."); } mod foo { fn bar() { //   ;     `foo`,  `serde_json` //    let json = serde_json::from_str("..."); } //   -        `use` use serde_json; fn baz() { //   -   `::serde_json`,   //  ,   let json = ::serde_json::from_str("..."); } } 

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

अंत में, टोकरे पर शुरू होने वाले रास्तों के साथ तत्वों के आयात का वर्तमान दायरे में समर्थन करना शुरू किया :

 mod foo { pub fn bar() { // ... } } //  use ::foo::bar; //  use foo::bar; //  use crate::foo::bar; 

पथ की शुरुआत में crate कीवर्ड इंगित करता है कि पथ पैकेट के मूल में शुरू होगा। इससे पहले, use आयात लाइन में इंगित पथ हमेशा पैकेज की जड़ के सापेक्ष निर्दिष्ट किए जाते थे, लेकिन शेष कोड में पथ जो सीधे तत्वों को संदर्भित करते हैं, वर्तमान मॉड्यूल के सापेक्ष निर्दिष्ट किए गए थे, जिससे पथों का परस्पर विरोधी व्यवहार हो गया था।

 mod foo { pub fn bar() { // ... } } mod baz { pub fn qux() { //  ::foo::bar(); //  ,    `use`: // foo::bar(); //  crate::foo::bar(); } } 

जैसे ही नई शैली का व्यापक रूप से उपयोग किया जाता है, यह बदसूरत उपसर्ग का उपयोग करने की आवश्यकता के बिना पूर्ण पथ को स्पष्ट रूप से स्पष्ट कर देगा :: ।

ये सभी परिवर्तन एक साथ इस बात की समझ को सरल बनाते हैं कि रास्ते कैसे हल होते हैं। जहाँ भी आपको पथ a::b::c , use कथन को छोड़कर, आप पूछ सकते हैं:

• पैकेज नाम है? फिर आपको इसके अंदर b::c तलाश करनी होगी।
• क्या a खोजशब्द crate ? फिर आपको वर्तमान पैकेज की जड़ से b::c तलाश करनी होगी।
• अन्यथा, आपको मॉड्यूल पदानुक्रम में वर्तमान स्थिति से a::b::c तलाश करनी होगी।

हमेशा पैकेज के मूल में शुरू होने वाले use में पथ का पुराना व्यवहार, अभी भी लागू है। लेकिन एक नई शैली में एक बार के संक्रमण के साथ, ये नियम समान रूप से हर जगह रास्तों पर लागू होंगे, और आपको चलते समय कोड के आयात के बारे में बहुत कम चिंता करनी होगी।

कच्चे पहचानकर्ता

अब आप निम्नलिखित नए सिंटैक्स का उपयोग करके कीवर्ड को पहचानकर्ता के रूप में उपयोग कर सकते हैं :

 //      `for` let r#for = true; //     `for` fn r#for() { // ... } //    r#for(); 

अब तक, ऐसे कई मामले नहीं हैं जब यह आपके लिए उपयोगी हो। लेकिन एक दिन आप Rust 2018 के लिए किसी प्रोजेक्ट में Rust 2015 के पैकेज का उपयोग करने का प्रयास करेंगे या इसके विपरीत, तब उनके कीवर्ड का सेट अलग होगा। हम रुस्त 2018 की आगामी घोषणा में इस बारे में अधिक बात करेंगे।

एक मानक पुस्तकालय के बिना आवेदन

रस्ट 1.6 में वापस, हमने एक मानक पुस्तकालय के बिना प्रोजेक्ट बनाने के लिए "no_std" और libcore के स्थिरीकरण की घोषणा की। हालांकि, एक स्पष्टीकरण के साथ: यह केवल पुस्तकालयों को बनाना संभव था, लेकिन आवेदन नहीं।

जंग 1.30 में, आप स्वतंत्र रूप से आतंक को लागू करने के लिए #[panic_handler] विशेषता का उपयोग कर सकते हैं। इसका मतलब यह है कि अब आप केवल लाइब्रेरी का उपयोग न करके मानक पुस्तकालय का उपयोग न करने वाले एप्लिकेशन बना सकते हैं।

अन्य

एक आखिरी चीज: मैक्रोज़ में, आप vis क्वालिफायर का उपयोग करके, जैसे कि pub जैसे स्कोप मॉडिफ़ायर को मैप कर सकते हैं। इसके अतिरिक्त, "टूल विशेषताएँ", जैसे कि #[rustfmt::skip] , अब स्थिर हो गई हैं । स्थैतिक विश्लेषण उपकरणों के साथ उपयोग के लिए सच है, जैसे #[allow(clippy::something)] , वे अभी तक स्थिर नहीं हैं।

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

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

इस रिलीज़ में निम्नलिखित API को स्थिर किया गया है:

• Ipv4Addr::{BROADCAST, LOCALHOST, UNSPECIFIED}
• Ipv6Addr::{BROADCAST, LOCALHOST, UNSPECIFIED}
• Iterator::find_map

इसके अलावा, मानक लाइब्रेरी में कुछ पाठ के एक तरफ रिक्त स्थान को हटाने के लिए कार्य होते हैं, जैसे कि trim_left । हालाँकि, RTL भाषाओं के लिए, यहाँ "सही" और "बाएँ" का अर्थ भ्रम पैदा करता है। इसलिए, हम इन कार्यों के लिए नए नाम पेश करते हैं:

• trim_left -> trim_start
• trim_right -> trim_end
• trim_left_matches -> trim_start_matches
• trim_right_matches -> trim_end_matches

हम रूस्त 1.33 में पुराने नामों को अप्रचलित (लेकिन हटाना नहीं, निश्चित रूप से) घोषित करना चाहते हैं।

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

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

इस रिलीज में कार्गो के लिए सबसे बड़ा सुधार यह है कि अब हमारे पास प्रगति पट्टी है!

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

डेवलपर्स 1.30.0

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

एक अनुवादक से: मैं रस्टीक्रेट समुदाय के सदस्यों और व्यक्तिगत रूप से इन विटावतु और वर्चुओस 86 के अनुवाद और प्रूफरीडिंग के लिए उनकी मदद के लिए विशेष आभार व्यक्त करता हूं।