जंग प्रोग्रामिंग भाषा अवलोकन

जंग मोज़िला द्वारा विकसित एक नई प्रयोगात्मक प्रोग्रामिंग भाषा है। भाषा संकलित और बहु-प्रतिमान है, इसे C / C ++ के विकल्प के रूप में तैनात किया गया है, जो अपने आप में दिलचस्प है, क्योंकि प्रतियोगिता के लिए इतने आवेदक नहीं हैं। आप Google से D Walter Bright या Go को याद कर सकते हैं।
जंग कार्यात्मक, समानांतर, प्रक्रियात्मक और वस्तु-उन्मुख प्रोग्रामिंग का समर्थन करती है, अर्थात। लगभग पूरे प्रतिमानों का स्पेक्ट्रम वास्तव में लागू प्रोग्रामिंग में उपयोग किया जाता है।

मैं प्रलेखन का अनुवाद करने के लिए बाहर सेट नहीं करता हूं (इसके अलावा, यह बहुत दुर्लभ है और लगातार बदल रहा है, क्योंकि अभी तक भाषा की आधिकारिक रिलीज नहीं हुई है), इसके बजाय मैं भाषा की सबसे दिलचस्प विशेषताओं को उजागर करना चाहता हूं। सूचना को आधिकारिक दस्तावेज से, और इंटरनेट पर भाषा के बहुत कम संदर्भों से एकत्र किया जाता है।

पहली छाप

भाषा का वाक्य-विन्यास पारंपरिक सी-जैसी शैली में बनाया गया है (जो आनन्दित नहीं कर सकता है, क्योंकि यह पहले से ही वास्तविक मानक है)। स्वाभाविक रूप से, प्रसिद्ध सी / सी ++ डिजाइन त्रुटियों को ध्यान में रखा जाता है।
एक पारंपरिक हैलो वर्ल्ड इस तरह दिखता है:

use std; fn main(args: [str]) { std::io::println("hello world from " + args[0] + "!"); } 

एक उदाहरण थोड़ा और अधिक जटिल है - भाज्य गणना कार्य:

 fn fac(n: int) -> int { let result = 1, i = 1; while i <= n { result *= i; i += 1; } ret result; } 

जैसा कि आप उदाहरण से देख सकते हैं, फ़ंक्शन "कार्यात्मक" शैली में घोषित किए गए हैं (इस शैली के पारंपरिक "int fac (int n)") पर कुछ फायदे हैं। हम स्वचालित तर्क को देखते हैं (कीवर्ड दें), तर्क में कोष्ठक की अनुपस्थिति (गो के समान)। कीवर्ड की कॉम्पैक्टनेस तुरंत स्पष्ट हो जाती है। रस्ट के रचनाकारों ने वास्तव में उद्देश्यपूर्ण रूप से सभी खोजशब्दों को यथासंभव छोटा कर दिया है, और ईमानदार होने के लिए, मुझे यह पसंद है।

छोटी लेकिन दिलचस्प वाक्य रचना सुविधाएँ

• अंडरस्कोर को संख्यात्मक स्थिरांक में डाला जा सकता है। एक आसान बात, अब इस सुविधा को कई नई भाषाओं में जोड़ा जा रहा है।
  0xffff_ffff_ffff_ffff_ffff_ffff
  
• बाइनरी स्थिरांक बेशक, एक वास्तविक प्रोग्रामर को अपने दिमाग में बिन को हेक्स में बदलना होगा, लेकिन यह अधिक सुविधाजनक है! 0b1111_1111_1001_0000
• किसी भी ऑपरेटर के शरीर (यहां तक ​​कि एक एकल अभिव्यक्ति वाले) को घुंघराले ब्रेसिज़ में संलग्न किया जाना चाहिए। उदाहरण के लिए, सी में, आप लिख सकते हैं if(x>0) foo(); , जंग में, आपको फू () के चारों ओर घुंघराले कोष्ठक लगाना चाहिए
• लेकिन अगर, जबकि और जैसे ऑपरेटरों के तर्कों को कोष्ठकों में संलग्न करने की आवश्यकता नहीं है
• कई मामलों में, कोड के ब्लॉक को अभिव्यक्ति माना जा सकता है। विशेष रूप से, उदाहरण के लिए, यह संभव है:
  

   let x = if the_stars_align() { 4 } else if something_else() { 3 } else { 0 }; 

• फ़ंक्शन घोषित करने के लिए सिंटैक्स - पहले कीवर्ड fn, फिर तर्कों की सूची, नाम के बाद तर्क का प्रकार इंगित किया जाता है, फिर यदि फ़ंक्शन मान लौटाता है, तो तीर "->" और वापसी मान का प्रकार
• चर उसी तरह से घोषित किए जाते हैं: लेट कीवर्ड, वैरिएबल का नाम, वैरिएबल के बाद, आप कोलन के बाद के प्रकार को निर्दिष्ट कर सकते हैं, और फिर प्रारंभिक मान निर्दिष्ट कर सकते हैं।
  let count: int = 5;
• डिफ़ॉल्ट रूप से, सभी चर अपरिवर्तनीय हैं; म्यूटेबल कीवर्ड का उपयोग म्यूटेबल वैरिएबल घोषित करने के लिए किया जाता है।
• बुनियादी प्रकारों के नाम मेरे द्वारा मिले सभी के सबसे कॉम्पैक्ट हैं: i8, i16, i32, i64, u8, u16, u32, u64, f32, f64
• जैसा कि ऊपर उल्लेख किया गया है, स्वत: प्रकार का अनुमान समर्थित है

भाषा में, प्रोग्राम के लिए अंतर्निहित डीबगिंग उपकरण हैं:
असफल कीवर्ड वर्तमान प्रक्रिया को समाप्त कर देता है।
लॉग कीवर्ड लॉग में किसी भी भाषा की अभिव्यक्ति प्रदर्शित करता है (उदाहरण के लिए, stderr में)
मुखर कीवर्ड अभिव्यक्ति को मान्य करता है, और यदि गलत है, तो वर्तमान प्रक्रिया को समाप्त कर देता है
कीवर्ड कीवर्ड आपको प्रक्रिया की असामान्य समाप्ति की स्थिति में अतिरिक्त जानकारी प्रदर्शित करने की अनुमति देता है।

डेटा प्रकार

गो, जैसे गो, संरचनात्मक टाइपिंग का समर्थन करता है (हालांकि, लेखकों के अनुसार, स्वतंत्र रूप से विकसित हुई भाषाएं, इसलिए यह उनके सामान्य पूर्ववर्तियों - एलेफ, लिम्बो, आदि का प्रभाव है)। संरचनात्मक टाइपिंग क्या है? उदाहरण के लिए, आपके पास कुछ फ़ाइल में घोषित संरचना है (या, रस्ट शब्दावली में, "रिकॉर्ड")
प्रकार बिंदु = {x: फ्लोट, y: फ्लोट};
आप तर्क प्रकार के बिंदुओं के साथ चर और कार्यों का एक गुच्छा घोषित कर सकते हैं। फिर, कहीं और, आप कुछ अन्य संरचना की घोषणा कर सकते हैं, उदाहरण के लिए
MySuperPoint = {x: float, y: float} टाइप करें;
और इस प्रकार के चर पूरी तरह से प्रकार के चर के साथ संगत होंगे।

इसके विपरीत, C, C ++, C # और Java में अपनाई गई नाममात्र की टाइपिंग इस तरह के निर्माण की अनुमति नहीं देती है। नाममात्र टाइपिंग के साथ, प्रत्येक संरचना एक अद्वितीय प्रकार है, जो डिफ़ॉल्ट रूप से अन्य प्रकारों के साथ असंगत है।

जंग में संरचनाओं को "रिकॉर्ड" कहा जाता है। टुपल्स भी हैं - ये एक ही रिकॉर्ड हैं, लेकिन अनाम क्षेत्रों के साथ। रिकॉर्डिंग तत्वों के विपरीत टपल तत्व, परस्पर भिन्न नहीं हो सकते।

वैक्टर हैं - कुछ हद तक नियमित सरणियों के समान, और कुछ में - std :: stl से वेक्टर। किसी सूची को शुरू करते समय, वर्ग कोष्ठक का उपयोग किया जाता है, और C / C ++ की तरह घुंघराले नहीं

 let myvec = [1, 2, 3, 4]; 

एक वेक्टर, फिर भी, एक गतिशील डेटा संरचना है, विशेष रूप से, वैक्टर संघनन का समर्थन करते हैं।

 let v: mutable [int] = [1, 2, 3]; v += [4, 5, 6]; 

पैटर्न हैं। C ++ से "टेम्पलेट" के ढेर के बिना उनका सिंटैक्स काफी तार्किक है। फ़ंक्शन टेम्प्लेट और डेटा प्रकार समर्थित हैं।

 fn for_rev<T>(v: [T], act: block(T)) { let i = std::vec::len(v); while i > 0u { i -= 1u; act(v[i]); } } type circular_buf<T> = {start: uint, end: uint, buf: [mutable T]}; 

भाषा तथाकथित टैग का समर्थन करती है। यह सी से एक संघ से अधिक कुछ नहीं है, एक अतिरिक्त क्षेत्र के साथ - उपयोग किए गए विकल्प का कोड (यानी, संघ और गणना के बीच सामान्य रूप से कुछ)। या, एक सिद्धांत के दृष्टिकोण से, एक बीजीय डेटा प्रकार।

 tag shape { circle(point, float); rectangle(point, point); } 

सरलतम मामले में, टैग गणना के समान है:

 tag animal { dog; cat; } let a: animal = dog; a = cat; 

अधिक जटिल मामलों में, "गणना" का प्रत्येक तत्व अपने स्वयं के "निर्माता" के साथ एक स्वतंत्र संरचना है।
एक और दिलचस्प उदाहरण एक पुनरावर्ती संरचना है, जिसकी सहायता से प्रकार "सूची" की एक वस्तु को परिभाषित किया गया है:

 tag list<T> { nil; cons(T, @list<T>); } let a: list<int> = cons(10, @cons(12, @nil)); 

टैग पैटर्न मिलान अभिव्यक्ति में भाग ले सकता है, जो काफी जटिल हो सकता है।

 alt x { cons(a, @cons(b, _)) { process_pair(a,b); } cons(10, _) { process_ten(); } _ { fail; } } 

पैटर्न मिलान

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

 alt my_number { 0 { std::io::println("zero"); } 1 | 2 { std::io::println("one or two"); } 3 to 10 { std::io::println("three to ten"); } _ { std::io::println("something else"); } } 

"पैटर्न" के रूप में, आप न केवल स्थिरांक (सी के रूप में) का उपयोग कर सकते हैं, बल्कि अधिक जटिल अभिव्यक्तियाँ भी कर सकते हैं - चर, टुपल्स, रेंज, प्रकार, प्लेसहोल्डर वर्ण (प्लेसहोल्डर, '_')। पैटर्न का पालन करते हुए, जब तुरंत कथन का उपयोग करके अतिरिक्त शर्तों को निर्दिष्ट किया जा सकता है। मैच प्रकारों के लिए एक विशेष ऑपरेटर विकल्प है। यह संभव है क्योंकि भाषा का एक सार्वभौमिक प्रकार है कोई भी , जिसकी वस्तुओं में किसी भी प्रकार के मूल्य हो सकते हैं।

संकेत दिए गए। सामान्य "पॉइंटर" पॉइंटर्स के अलावा, रूस्ट अंतर्निहित संदर्भ गणना के साथ विशेष "स्मार्ट" पॉइंटर्स का समर्थन करता है - साझा (साझा बॉक्स) और अद्वितीय (यूनिक बॉक्स)। वे C ++ से कुछ हद तक shared_ptr और unique_ptr के समान हैं। उनके पास अपना स्वयं का सिंटैक्स है: @ साझा के लिए और ~ अद्वितीय के लिए। अद्वितीय बिंदुओं के लिए, नकल करने के बजाय, एक विशेष ऑपरेशन है - चलती:

 let x = ~10; let y <- x; 

इस तरह के एक कदम के बाद, सूचक एक्स असमान है।

क्लोजर, आंशिक उपयोग, पुनरावृत्तियों

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

1. लैम्ब्डा कीवर्ड का उपयोग नेस्टेड फंक्शन या फंक्शन डेटा प्रकार घोषित करने के लिए किया जाता है।

 fn make_plus_function(x: int) -> lambda(int) -> int { lambda(y: int) -> int { x + y } } let plus_two = make_plus_function(2); assert plus_two(3) == 5; 

इस उदाहरण में, हमारे पास एक मेकप्लस_फंक्शन फ़ंक्शन है जो टाइप के int के एक तर्क "x" को लेता है और "int-> int" प्रकार का एक फ़ंक्शन देता है (यहां लैम्ब्डा कीवर्ड है)। यह फ़ंक्शन फ़ंक्शन के शरीर में वर्णित है। "रिटर्न" ऑपरेटर की अनुपस्थिति थोड़ा भ्रामक है, हालांकि, एफपी के लिए यह एक सामान्य बात है।

2. ब्लॉक कीवर्ड का उपयोग एक कार्यात्मक प्रकार घोषित करने के लिए किया जाता है - एक फ़ंक्शन के लिए एक तर्क, जिसे नियमित कोड के ब्लॉक की तरह दिखने वाली चीज़ के लिए प्रतिस्थापित किया जा सकता है।

 fn map_int(f: block(int) -> int, vec: [int]) -> [int] { let result = []; for i in vec { result += [f(i)]; } ret result; } map_int({|x| x + 1 }, [1, 2, 3]); 

यहां हमारे पास एक फ़ंक्शन है, जिसमें से एक ब्लॉक की आपूर्ति की जाती है - अनिवार्य रूप से "इंट-> इंट" प्रकार का एक लंबो फ़ंक्शन, और एक प्रकार का वेक्टर इंट (नीचे वैक्टर के सिंटैक्स के बारे में)। कॉलिंग कोड में "ब्लॉक" स्वयं कुछ असामान्य सिंटैक्स {x | x + 1}। व्यक्तिगत रूप से, मुझे C # में लैम्बदास पसंद है, प्रतीक | यह दृढ़ता से बिटवाइज़ या (जो, वैसे, रुस्त में भी मौजूद है, सभी पुराने अच्छे syshny संचालन की तरह) माना जाता है।

3. एक आंशिक अनुप्रयोग इस फ़ंक्शन के कुछ तर्कों के मूल्यों को इंगित करके बड़ी संख्या में तर्कों के साथ दूसरे फ़ंक्शन पर आधारित एक फ़ंक्शन का निर्माण है। ऐसा करने के लिए, बाइंड कीवर्ड और प्लेसहोल्डर "_" का उपयोग करें:

 let daynum = bind std::vec::position(_, ["mo", "tu", "we", "do", "fr", "sa", "su"]) 

इसे स्पष्ट करने के लिए, मैं तुरंत कहता हूं कि यह साधारण सी में एक साधारण आवरण बनाकर किया जा सकता है, कुछ इस तरह से:
const char* daynum (int i) { const char *s ={"mo", "tu", "we", "do", "fr", "sa", "su"}; return s[i]; }

लेकिन एक आंशिक आवेदन एक कार्यात्मक शैली है, न कि एक प्रक्रियात्मक एक (वैसे, यह उपरोक्त उदाहरण से स्पष्ट नहीं है कि तर्कों के बिना एक फ़ंक्शन प्राप्त करने के लिए आंशिक आवेदन कैसे करें)

एक और उदाहरण: ऐड फ़ंक्शन दो इंट तर्क के साथ घोषित किया जाता है, एक इंट लौटाता है। इसके बाद, कार्यात्मक प्रकार एकल_परम_एफएन घोषित किया जाता है, जिसमें एक अंतर तर्क होता है और एक इंट रिटर्न होता है। बाइंड का उपयोग करके, दो फ़ंक्शन ऑब्जेक्ट add4 और add5 घोषित किए जाते हैं, जो ऐड फ़ंक्शन के आधार पर बनाए जाते हैं, जिसमें आंशिक रूप से तर्क दिए गए हैं।

 fn add(x: int, y: int) -> int { ret x + y; } type single_param_fn = fn(int) -> int; let add4: single_param_fn = bind add(4, _); let add5: single_param_fn = bind add(_, 5); 

क्रियात्मक वस्तुओं को नियमित कार्यों की तरह ही कहा जा सकता है।

 assert (add(4,5) == add4(5)); assert (add(4,5) == add5(4)); 

4. शुद्ध कार्य और भविष्यवाणी
शुद्ध कार्य ऐसे कार्य हैं जिनके साइड इफेक्ट नहीं होते हैं (उन लोगों सहित जो शुद्ध के अलावा किसी भी कार्य को नहीं कहते हैं)। इस तरह के फ़ंक्शंस कीवर्ड द्वारा शुद्ध किए जाते हैं।

  pure fn lt_42(x: int) -> bool { ret (x < 42); } 

विधेय शुद्ध कार्य हैं जो एक बूल प्रकार को लौटाते हैं। इस तरह के कार्यों का उपयोग टाइपस्टेट सिस्टम (नीचे देखें) में किया जा सकता है, अर्थात, उन्हें विभिन्न स्थैतिक जाँच के लिए संकलन चरण में बुलाया जाता है।

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

 std::io::println(#fmt("%s is %d", "the answer", 42)); 

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

गुण

C # विशेषताओं के समान एक अवधारणा (और समान सिंटैक्स के साथ भी)। इसके लिए, डेवलपर्स के लिए विशेष धन्यवाद। जैसा कि अपेक्षित था, विशेषताएँ मेटा-सूचना को उस इकाई में जोड़ते हैं जो वे एनोटेट करते हैं,

 #[cfg(target_os = "win32")] fn register_win_service() { /* ... */ } 

विशेषता सिंटैक्स के एक और संस्करण का आविष्कार किया गया था - एक ही पंक्ति, लेकिन अंत में एक अर्धविराम के साथ, वर्तमान संदर्भ को एनोटेट करता है। यही है, जो ऐसी विशेषता को कवर करने वाले निकटतम घुंघराले ब्रेसिज़ से मेल खाता है।

 fn register_win_service() { #[cfg(target_os = "win32")]; /* ... */ } 

समानांतर कंप्यूटिंग

शायद भाषा के सबसे दिलचस्प हिस्सों में से एक। इसके अलावा, ट्यूटोरियल वर्तमान में बिल्कुल भी वर्णित नहीं है :)
रस्ट प्रोग्राम में "टास्क ट्री" होता है। प्रत्येक कार्य में एक इनपुट फ़ंक्शन होता है, इसका अपना स्टैक, अन्य कार्यों के साथ बातचीत का साधन - आने वाली जानकारी के लिए चैनल और आने वाले के लिए पोर्ट, और डायनामिक हीप में कुछ वस्तुओं का मालिक है।
एक ही ऑपरेटिंग सिस्टम प्रक्रिया के भीतर कई जंग कार्य मौजूद हो सकते हैं। जंग कार्य "हल्के" हैं: प्रत्येक कार्य ओएस प्रक्रिया की तुलना में कम मेमोरी का उपभोग करता है, और उनके बीच स्विच करना ओएस प्रक्रियाओं के बीच स्विच करने की तुलना में तेज है (यहां, संभवतः, सभी समान "प्रवाह" का मतलब है)।

एक कार्य में कम से कम एक फ़ंक्शन होता है जिसमें कोई तर्क नहीं होता है। कार्य स्पॉन फ़ंक्शन का उपयोग करके लॉन्च किया गया है। प्रत्येक कार्य में चैनल हो सकते हैं जिसके माध्यम से वह अन्य कार्यों के लिए जानकारी स्थानांतरित करता है। एक चैनल एक विशेष चान प्रकार का टेम्प्लेट है जिसे चैनल डेटा प्रकार द्वारा परिचालित किया जाता है। उदाहरण के लिए, चान अहस्ताक्षरित बाइट्स को प्रसारित करने के लिए एक चैनल है।
चैनल को भेजने के लिए, सेंड फंक्शन का उपयोग किया जाता है, जिसमें से पहला तर्क चैनल है, और दूसरा भेजने का मान है। वास्तव में, यह फ़ंक्शन आंतरिक चैनल बफर में मूल्य रखता है।
पोर्ट का उपयोग डेटा प्राप्त करने के लिए किया जाता है। एक पोर्ट एक सामान्य पोर्ट प्रकार है, जिसे पोर्ट डेटा प्रकार द्वारा पोर्टिज्म किया जाता है: अहस्ताक्षरित बाइट प्राप्त करने के लिए पोर्ट - पोर्ट।
पोर्ट से पढ़ने के लिए, आरईवी फ़ंक्शन का उपयोग किया जाता है, जिनमें से तर्क पोर्ट है, और रिटर्न वैल्यू पोर्ट से डेटा है। पढ़ना कार्य को अवरुद्ध करता है, अर्थात्। यदि पोर्ट खाली है, तो कार्य प्रतीक्षा की स्थिति में जाता है जब तक कि कोई अन्य कार्य पोर्ट से जुड़े चैनल को डेटा नहीं भेजता है।
चैनल को पोर्ट से लिंक करना बहुत सरल है - चैनल का उपयोग करके पोर्ट को चैनल से आरंभ करना
let reqport = port();
let reqchan = chan(reqport);
कई चैनल एक पोर्ट से कनेक्ट हो सकते हैं, लेकिन इसके विपरीत नहीं - एक चैनल एक साथ कई पोर्ट से कनेक्ट नहीं किया जा सकता है।

Typestate

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

उदाहरण के लिए, यदि हमारे पास "फ़ाइल" प्रकार की कोई वस्तु है, तो इसमें "बंद" और "ओपन" की स्थिति हो सकती है। और फ़ाइल बंद होने पर फ़ाइल से पढ़ने का संचालन अस्वीकार्य है। आधुनिक भाषाओं में, आमतौर पर पढ़ा गया फ़ंक्शन या तो एक अपवाद को फेंक देता है या एक त्रुटि कोड देता है। टाइप स्टेट सिस्टम संकलन चरण पर इस तरह की त्रुटि का पता लगा सकता है - जिस तरह कंपाइलर यह निर्धारित करता है कि किसी भी संभावित लेखन ऑपरेशन से पहले एक वैरिएबल रीड ऑपरेशन होता है, यह निर्धारित कर सकता है कि रीड विधि, जो फ़ाइल ओपन स्टेट में मान्य है, कहा जाता है "ओपन" विधि के लिए, जो वस्तु को इस स्थिति में स्थानांतरित करता है।

जंग की एक अवधारणा है "भविष्यवाणी" - ऐसे विशेष कार्य जिनके कोई दुष्प्रभाव नहीं हैं और एक बूल प्रकार वापस करते हैं। इस तरह के कार्यों का उपयोग कंपाइलर द्वारा कुछ स्थितियों की स्थैतिक जाँच के उद्देश्य से संकलन चरण में करने के लिए किया जा सकता है।

बाधाएं विशेष जांच हैं जिन्हें संकलन के चरण में किया जा सकता है। ऐसा करने के लिए, चेक कीवर्ड का उपयोग करें।

 pure fn is_less_than(int a, int b) -< bool { ret a < b; } fn test() { let x: int = 10; let y: int = 20; check is_less_than(x,y); } 

विधेयकों को इस तरह से कार्यों के इनपुट मापदंडों पर "लटका" दिया जा सकता है:

 fn test(int x, int y) : is_less_than(x,y) { ... } 

टाइपटेस्ट पर बहुत कम जानकारी है, इतने सारे अंक अभी तक स्पष्ट नहीं हैं, लेकिन अवधारणा वैसे भी दिलचस्प है।

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