🆕 🤜🏽 🤲🏽 जंग के साथ दहनशील पार्सर की खोज 👩🏿‍💼 🙏🏽 👐🏿

नमस्कार, हेब्र! मैं आपके लिए "लर्निंग पार्सर कॉम्बिनेटर विथ रस्ट" लेख का अनुवाद प्रस्तुत करता हूं।

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

शुरुआत के दृष्टिकोण से

प्रत्येक प्रोग्रामर के जीवन में, एक समय आता है जब उसे एक पार्सर की आवश्यकता होती है।

एक नौसिखिया प्रोग्रामर पूछेगा: "एक पार्सर क्या है?"

मध्य-स्तरीय प्रोग्रामर कहेगा: "यह सरल है, मैं एक नियमित अभिव्यक्ति लिखूंगा।"

मास्टर प्रोग्रामर कहेगा: "दूर हो जाओ, मुझे पता है कि lex और yacc।"

एक नौसिखिया सबसे अच्छा लगता है।

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

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

इस लेख के साथ कैसे काम करें

यह दृढ़ता से अनुशंसा की जाती है कि आप एक नई जंग परियोजना के साथ शुरू करें और src/lib.rs में कोड स्निपेट src/lib.rs जैसा कि आप पढ़ते हैं (आप इसे सीधे पेज से पेस्ट कर सकते हैं, लेकिन इसे बेहतर दर्ज करें, क्योंकि यह स्वचालित रूप से आपको गारंटी देता है कि आप इसे पूरी तरह से पढ़ेंगे)। कोड के सभी भाग जिनकी आपको आवश्यकता है, लेख में क्रम में व्यवस्थित किए गए हैं। ध्यान रखें कि कभी-कभी आपके द्वारा लिखे गए कार्यों के संशोधित संस्करण पेश किए जाते हैं, और इन मामलों में आपको पुराने संस्करण को नए के साथ बदलना होगा।

कोड को 2018 भाषा संस्करण का उपयोग करते हुए rustc संस्करण 1.34.0 के लिए लिखा गया था। आप संकलक के किसी भी संस्करण का उपयोग कर सकते हैं, सुनिश्चित करें कि आप एक रिलीज़ का उपयोग कर रहे हैं जो 2018 संस्करण का समर्थन करता है (सुनिश्चित करें कि आपके Cargo.toml में edition = "2018" )। इस परियोजना को बाहरी निर्भरता की आवश्यकता नहीं है।

अपेक्षा के अनुसार लेख में प्रस्तुत किए गए परीक्षणों को करने के लिए, cargo test ।

Xcruciating Markup भाषा

हम XML के सरलीकृत संस्करण के लिए एक पार्सर लिखने जा रहे हैं। यह इस तरह दिखता है:

 <parent-element> <single-element attribute="value" /> </parent-element>

XML तत्वों को < अक्षर और एक पहचानकर्ता के साथ खोला जाता है जिसमें किसी भी अक्षर, संख्या और - बाद एक अक्षर शामिल होता है। इसके बाद रिक्त स्थान और विशेषता जोड़े की एक वैकल्पिक सूची है: पहले से परिभाषित एक और पहचानकर्ता, उसके बाद = और दोहरे उद्धरण में एक स्ट्रिंग। अंत में, बच्चों के बिना एक तत्व को इंगित करने के लिए या तो एक समापन /> चरित्र होता है, या > बाल तत्वों के अगले अनुक्रम के अस्तित्व को इंगित करने के लिए, और एक समापन टैग </ साथ शुरू होता है, उसके बाद एक पहचानकर्ता होता है जो प्रारंभिक टैग और एक समापन चरित्र से मेल खाना चाहिए।

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

हम इन तत्वों को एक संरचना में पार्स करने जा रहे हैं जो इस तरह दिखता है:

 #[derive(Clone, Debug, PartialEq, Eq)] struct Element { name: String, attributes: Vec<(String, String)>, children: Vec<Element>, }

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

(यदि आप प्रिंट कर रहे हैं, तो derive अनुभाग को शामिल करना सुनिश्चित करें। आपको बाद में इसकी आवश्यकता होगी।)

Parser परिभाषा;

खैर, यह एक parser लिखने का समय है।

पार्सिंग सूचना की एक धारा से संरचित डेटा प्राप्त करने की प्रक्रिया है। एक पार्सर वह है जो इस संरचना को सामने लाता है।

अनुशासन में हम खोज करने जा रहे हैं, पार्सर, अपने सरलतम रूप में, एक फ़ंक्शन है जो कुछ इनपुट लेता है और शेष इनपुट के साथ पार्स किए गए आउटपुट या रिटर्न देता है, या एक त्रुटि कहती है "मैं इसे पार्स नहीं कर सकता।"

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

इसे एक प्रकार के फंक्शन के रूप में लिखते हैं।

 Fn(Input) -> Result<(Input, Output), Error>

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

 Fn(&str) -> Result<(&str, Element), &str>

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

यह उपयोग करने के लिए क्लीनर हो सकता है &[u8] (इनपुट के रूप में ASCII वर्णों से मेल खाता बाइट्स का एक टुकड़ा), विशेष रूप से क्योंकि स्ट्रिंग स्लाइस अधिकांश स्लाइसों की तुलना में थोड़ा अलग व्यवहार करते हैं - खासकर जब से आप उन्हें एक के साथ अनुक्रमित नहीं कर सकते हैं नंबर input[0] , आपको टुकड़ा input[0..1] उपयोग करना चाहिए। दूसरी ओर, उनके पास कई तरीके हैं जो पार्सिंग स्ट्रिंग्स के लिए उपयोगी होते हैं जिनमें बाइट स्लाइस नहीं होते हैं।

वास्तव में, हम तरीकों पर भरोसा करेंगे, न कि चरित्र सूचकांक का उपयोग, क्योंकि यूनिकोड। UTF-8 में, और सभी Rust स्ट्रिंग्स मान्य UTF-8 स्ट्रिंग्स हैं, ये सूचकांक हमेशा अलग-अलग वर्णों के अनुरूप नहीं होते हैं, और सभी इच्छुक पार्टियों के लिए बेहतर है कि वे मानक पुस्तकालय को हमारे साथ काम करने के लिए कहें।

हमारा पहला पार्सर

आइए एक ऐसे पार्सर को लिखने का प्रयास करें जो सिर्फ एक स्ट्रिंग में पहले चरित्र को देखता है
और यह तय करता है कि क्या यह पत्र a ।

 fn the_letter_a(input: &str) -> Result<(&str, ()), &str> { match input.chars().next() { Some('a') => Ok((&input['a'.len_utf8()..], ())), _ => Err(input), } }

सबसे पहले, इनपुट और आउटपुट के प्रकारों को देखें: हम इनपुट के रूप में एक स्ट्रिंग स्लाइस लेते हैं और हम (&str, ()) , या &str साथ एक त्रुटि के साथ Result देते हैं। जोड़ी (&str, ()) एक दिलचस्प बिंदु है: जैसा कि हमने कहा कि हमें निम्नलिखित सामग्री का एक टपल वापस करना चाहिए,
पार्सिंग परिणाम और बाकी इनपुट। &str अगला इनपुट है, और परिणाम सिर्फ एक ब्लॉक प्रकार () , क्योंकि यदि यह पार्सर सफलतापूर्वक काम करता है, तो इसका केवल एक परिणाम हो सकता है (हमें पत्र मिला), और हमें वास्तव में वापस आने की आवश्यकता नहीं है
पत्र इस मामले में हमें केवल यह इंगित करने की आवश्यकता है कि हम इसे खोजने में कामयाब रहे।

तो, चलो पार्सर के कोड को ही देखें। हमने मजाक नहीं किया कि मानक पुस्तकालय पर भरोसा करने से हम यूनिकोड के साथ सिरदर्द से बच सकते हैं: हमें chars() विधि का उपयोग करके स्ट्रिंग के पात्रों पर एक पुनरावृत्ति प्राप्त होती है और इसमें से पहला चरित्र लेते हैं। यह Option में लिपटे टाइप char का एक तत्व होगा, जिसमें None भी इसका मतलब None होगा कि हम खाली स्ट्रिंग से char खींचने की कोशिश कर रहे थे।

मामलों को बदतर बनाने के लिए, char जरूरी नहीं है कि आप इसे एक यूनिकोड चरित्र के रूप में भी सोचते हैं। ऐसा होने की संभावना है कि यूनिकोड एक "ग्रैफेम क्लस्टर" कहलाता है, जिसमें कई char शामिल हो सकते हैं, जो वास्तव में "स्केलर वैल्यूज़" होते हैं , जो ग्रैफेमी क्लस्टर से दो स्तर नीचे होते हैं। हालाँकि, यह मार्ग पागलपन की ओर जाता है, और हमारे उद्देश्यों के लिए, हम ईमानदारी से ASCII के बाहर chars देखने की संभावना नहीं है, तो चलो वहाँ रुकें।

हम Some('a') पैटर्न के लिए मैप करते हैं, जो कि हमारे द्वारा खोजे जा रहे विशिष्ट परिणाम है, और यदि वह मैच होता है, तो हम अपनी सफलता की वापसी करते हैं:
Ok((&input['a'.len_utf8()..], ())) । यही है, हम उस भाग को हटा देते हैं जिसे हमने लाइन स्लाइस से पार्स ( 'a' ) किया है और बाकी को अपने पार्स किए गए मान के साथ लौटाते हैं, जो अभी खाली है
() । हमेशा यूनिकोड राक्षस को याद करते हुए, काटने से पहले, हम मानक पुस्तकालय के माध्यम से चरित्र 'a' की यूटीएफ -8 में लंबाई का पता लगाते हैं - यह 1 है (लेकिन यूनिकोड राक्षस के बारे में कभी नहीं भूलना चाहिए)।

यदि हमें कोई अन्य Some(char) मिलता है, या यदि हमें None मिलता है, तो हम एक त्रुटि लौटाते हैं। जैसा कि आप याद करते हैं, हमारी त्रुटि का प्रकार केवल एक स्ट्रिंग टुकड़ा है, जिसे हमने input रूप में पारित किया input और जिसे पार्स नहीं किया जा सकता है। इसकी शुरुआत a , इसलिए यह हमारी गलती है। यह एक बड़ी गलती नहीं है, लेकिन कम से कम यह "कहीं न कहीं कुछ गलत है" की तुलना में थोड़ा बेहतर है।

हमें XML को पार्स करने के लिए वास्तव में इस पार्सर की आवश्यकता नहीं है, लेकिन पहली चीज जो हमें करनी होगी वह है शुरुआती चरित्र को ढूंढना < , इसलिए हमें कुछ इसी तरह की आवश्यकता है। हमें विशेष रूप से > , / और = को पार्स करने की आवश्यकता होगी, इसलिए हो सकता है कि हम एक ऐसा फ़ंक्शन बना सकें जो हम चाहते हैं चरित्र के लिए पार्सर बनाता है?

पार्सर बनाना

आइए इसके बारे में भी सोचते हैं: हम एक फ़ंक्शन लिखेंगे जो किसी भी लंबाई के स्थिर स्ट्रिंग के लिए एक पार्सर बनाता है, और केवल एक चरित्र नहीं। यह और भी सरल है क्योंकि लाइन का टुकड़ा पहले से ही एक वैध UTF-8 लाइन टुकड़ा है, और हमें यूनिकोड राक्षस के बारे में सोचने की जरूरत नहीं है।

 fn match_literal(expected: &'static str) -> impl Fn(&str) -> Result<(&str, ()), &str> { move |input| match input.get(0..expected.len()) { Some(next) if next == expected => { Ok((&input[expected.len()..], ())) } _ => Err(input), } }

अब यह थोड़ा अलग दिखता है।

सबसे पहले, आइए प्रकारों को देखें। अब हमारा कार्य एक expected स्ट्रिंग को तर्क के रूप में लेता है और एक पार्सर के समान कुछ देता है, न कि स्वयं पार्सर होने के बजाय। यह एक ऐसा फंक्शन है जो एक उच्च ऑर्डर फ़ंक्शन देता है । अनिवार्य रूप से, हम एक फ़ंक्शन लिख रहे हैं जो पहले हमारे the_letter_a फ़ंक्शन के समान फ़ंक्शन बनाता है ।

इस प्रकार, फ़ंक्शन के शरीर में काम करने के बजाय, हम एक क्लोजर लौटाते हैं जो इस काम को करता है और जो पिछले एक से विश्लेषक के लिए हमारे प्रकार के हस्ताक्षर से मेल खाता है।

पैटर्न मिलान समान दिखता है, सिवाय इसके कि हम अपने स्ट्रिंग शाब्दिक से सीधे मेल नहीं खा सकते हैं, क्योंकि हम नहीं जानते कि वास्तव में क्या होता है, इसलिए हम मिलान स्थिति का उपयोग करते हैं if next == expected । अन्यथा, यह सर्किट के शरीर के अंदर पहले की तरह ही है।

हमारे पार्सर का परीक्षण

आइए इसके लिए एक परीक्षण लिखें ताकि यह सुनिश्चित हो सके कि हम इसे ठीक कर लें।

 #[test] fn literal_parser() { let parse_joe = match_literal("Hello Joe!"); assert_eq!( Ok(("", ())), parse_joe("Hello Joe!") ); assert_eq!( Ok((" Hello Robert!", ())), parse_joe("Hello Joe! Hello Robert!") ); assert_eq!( Err("Hello Mike!"), parse_joe("Hello Mike!") ); }

पहले हम एक पार्सर बनाते हैं: match_literal("Hello Joe!") । यह स्ट्रिंग का उपभोग करना चाहिए "Hello Joe!" और बाकी स्ट्रिंग वापस करें, या विफल रहें और पूरे स्ट्रिंग को वापस करें।

पहले मामले में, हम इसे ठीक वही पंक्ति पास करते हैं जिसकी हम अपेक्षा करते हैं, और देखते हैं कि यह एक खाली स्ट्रिंग और मान लौटाता है () , जिसका अर्थ है "हमने अपेक्षित स्ट्रिंग का विश्लेषण किया है, और आपको इसे वापस करने की आवश्यकता नहीं है।"

दूसरे में, हम स्ट्रिंग को खिलाते हैं "Hello Joe! Hello Robert!" और हम देखते हैं कि वह वास्तव में स्ट्रिंग का उपयोग करता है "Hello Joe!" और इनपुट के शेष को लौटाता है: " Hello Robert!" (अग्रणी स्थान और बाकी सब कुछ)।

तीसरे में, हम गलत इनपुट दर्ज करते हैं: "Hello Mike!" और ध्यान दें कि यह वास्तव में एक त्रुटि के साथ इनपुट को अस्वीकार करता है। ऐसा नहीं है कि Mike गलत है, आमतौर पर सिर्फ वही नहीं जो पार्सर की तलाश में था।

कुछ कम विशिष्ट के लिए पार्सर

तो यह हमें < , > , = और यहां तक कि </ और /> का विश्लेषण करने की अनुमति देता है। हम लगभग हो चुके हैं!

प्रारंभिक चरित्र के बाद अगला < तत्व का नाम है। हम एक साधारण स्ट्रिंग तुलना के साथ ऐसा नहीं कर सकते। लेकिन हम इसे regex के साथ कर सकते हैं ...

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

तत्व के नाम के पहचानकर्ता के लिए नियम को याद करें, यह इस तरह दिखता है: एक वर्णमाला वर्ण, जिसके बाद शून्य या किसी वर्णमाला के प्रतीक का अधिक होना,
चरित्र, संख्या या डैश।

 fn identifier(input: &str) -> Result<(&str, String), &str> { let mut matched = String::new(); let mut chars = input.chars(); match chars.next() { Some(next) if next.is_alphabetic() => matched.push(next), _ => return Err(input), } while let Some(next) = chars.next() { if next.is_alphanumeric() || next == '-' { matched.push(next); } else { break; } } let next_index = matched.len(); Ok((&input[next_index..], matched)) }

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

इसे ध्यान में रखते हुए, हम पहले एक खाली String बनाते हैं और इसे matched कहते हैं। यह हमारा परिणाम होगा। हमें input में पात्रों के लिए एक पुनरावृत्ति भी मिलती है, जिसे हम विभाजित करना शुरू करने जा रहे हैं।

पहला कदम यह देखना है कि क्या शुरुआत में कोई प्रतीक है। हम पहले अक्षर को next.is_alphabetic() और जाँचते हैं कि क्या वह अक्षर है: next.is_alphabetic() । मानक रस्ट लाइब्रेरी, निश्चित रूप से, हमें यूनिकोड के साथ मदद करेगी - यह किसी भी वर्णमाला में अक्षरों के अनुरूप होगा, और न केवल एएससीआईआई में। यदि यह एक पत्र है, तो हम इसे matched स्ट्रिंग में हमारे स्ट्रिंग में डालते हैं, और यदि नहीं, तो हम तत्व के पहचानकर्ता को नहीं देखते हैं और तुरंत एक त्रुटि के साथ लौटते हैं।

दूसरे चरण में, हम is_alphanumeric() से वर्णों को खींचते रहते हैं, उन्हें उस पंक्ति तक भेजते हैं, जिसे हम तब तक बनाते हैं जब तक कि हमें is_alphanumeric() चरित्र नहीं is_alphanumeric() जो is_alphanumeric() फ़ंक्शन को संतुष्ट नहीं करता (यह is_alphabetic() समान है is_alphabetic() इसके अलावा इसमें किसी वर्णमाला में संख्याएँ भी शामिल हैं) या पानी '-' छींटा '-' ।

जब हम पहली बार ऐसा कुछ देखते हैं जो इन मानदंडों को पूरा नहीं करता है, तो हम पार्सिंग को समाप्त करते हैं, लूप को तोड़ते हैं और एक String लौटाते हैं, जो हम input से उपयोग किए गए टुकड़े को काटने के लिए याद करते हैं। इसी तरह, यदि वर्ण एक पुनरावृत्त में समाप्त होते हैं, तो इसका मतलब है कि हम इनपुट के अंत तक पहुंच गए हैं।

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

याद रखें कि Element संरचना वह है जो हम अपने XML दस्तावेज़ को पार्स करने जा रहे हैं।

 struct Element { name: String, attributes: Vec<(String, String)>, children: Vec<Element>, }

वास्तव में, हमने पहले भाग, name क्षेत्र के लिए विश्लेषक को समाप्त कर दिया। String जो हमारे पार्सर रिटर्न को सीधे वहां ले जाती है। यह प्रत्येक attribute के पहले भाग के लिए सही पार्सर भी है।

आइए इसे देखें।

 #[test] fn identifier_parser() { assert_eq!( Ok(("", "i-am-an-identifier".to_string())), identifier("i-am-an-identifier") ); assert_eq!( Ok((" entirely an identifier", "not".to_string())), identifier("not entirely an identifier") ); assert_eq!( Err("!not at all an identifier"), identifier("!not at all an identifier") ); }

हम देखते हैं कि पहले मामले में, स्ट्रिंग "i-am-an-identifier" पूरी तरह "i-am-an-identifier" पार्स है, केवल एक खाली स्ट्रिंग छोड़ रहा है। दूसरे मामले में, पार्सर एक पहचानकर्ता के रूप में "not" देता है, और शेष स्ट्रिंग को शेष इनपुट के रूप में वापस किया जाता है। तीसरे मामले में, पार्सर तुरंत विफल हो जाता है, क्योंकि पहला वर्ण जो इसे पाता है वह एक अक्षर नहीं है।

combinators

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

 fn pair<P1, P2, R1, R2>(parser1: P1, parser2: P2) -> impl Fn(&str) -> Result<(&str, (R1, R2)), &str> where P1: Fn(&str) -> Result<(&str, R1), &str>, P2: Fn(&str) -> Result<(&str, R2), &str>, { move |input| match parser1(input) { Ok((next_input, result1)) => match parser2(next_input) { Ok((final_input, result2)) => Ok((final_input, (result1, result2))), Err(err) => Err(err), }, Err(err) => Err(err), } }

यहां थोड़ा मुश्किल हो जाता है, लेकिन आप जानते हैं कि क्या करना है: प्रकारों को देखकर शुरू करें।

सबसे पहले, हमारे पास चार प्रकार के चर हैं: P1 , P1 P2 , R1 और R2 । ये हैं Parser 1 , Parser 2 , Result 1 और Result 2 । P1 और P2 फ़ंक्शंस हैं, और आप देखेंगे कि वे पार्सर फ़ंक्शंस के एक अच्छी तरह से स्थापित पैटर्न का पालन करते हैं: रिटर्न वैल्यू की तरह, वे इनपुट के रूप में लेते हैं &str इनपुट के रूप में लेते हैं और वापस लौटते हैं और शेष इनपुट और परिणाम, या एक त्रुटि Result जोड़ी का परिणाम देते हैं।

लेकिन प्रत्येक फ़ंक्शन के परिणाम प्रकारों को देखें: P1 वह पार्सर है जो R1 देता है यदि सफल होता है, और P2 भी R2 देता है। और हमारे फ़ंक्शन से वापस लाए गए अंतिम पार्सर का परिणाम है (R1, R2) । इस प्रकार, इस पार्सर का कार्य पहले इनपुट पर विश्लेषक P1 को शुरू करना है, इसके परिणाम को सहेजना है, फिर P1 लौटाने वाले इनपुट पर P2 शुरू करना है, और यदि दोनों काम करते हैं, तो हम दो परिणामों को एक ट्यूपल (R1, R2) में संयोजित करते हैं। (R1, R2) ।

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

इस प्रकार, हमें वास्तव में हमारे पहले XML टैग match_literal पहले टुकड़े को match_literal करने के लिए हमारे दो पार्सर्स, match_literal और identifier को मिलाने में सक्षम होना चाहिए। चलो यह देखने के लिए कि क्या काम करता है, एक परीक्षण लिखें।

 #[test] fn pair_combinator() { let tag_opener = pair(match_literal("<"), identifier); assert_eq!( Ok(("/>", ((), "my-first-element".to_string()))), tag_opener("<my-first-element/>") ); assert_eq!(Err("oops"), tag_opener("oops")); assert_eq!(Err("!oops"), tag_opener("<!oops")); }

काम करने लगता है! लेकिन इस प्रकार के परिणाम को देखें: ((), String) । जाहिर है, हम केवल सही मूल्य में रुचि रखते हैं, String । यह काफी बार होगा - हमारे कुछ पार्सर केवल उत्पादन मूल्यों के बिना इनपुट में पैटर्न से मेल खाते हैं, और इसलिए उनके आउटपुट को सुरक्षित रूप से अनदेखा किया जा सकता है। इस पैटर्न के अनुकूल होने के लिए, हम दो अन्य कॉम्बीनेटरों को लिखने के लिए अपनी pair कॉम्बिनेटर का उपयोग करने जा रहे हैं: left , जो पहले पार्सर के परिणाम को बताता है और केवल दूसरे को लौटाता है, और इसके विपरीत right । हमने ऊपर अपने परीक्षण में एक पार्सर का उपयोग किया है, जो बाएं हिस्से को छोड़ देता है और pair बजाय केवल हमारे String बचाता है।

फन्नेकार परिचय

लेकिन इससे पहले कि हम आगे बढ़ते हैं, आइए एक और कॉम्बिनेटर का परिचय दें जो इन दो: map के लेखन को बहुत सरल करेगा।

इस कॉम्बीनेटर का एक काम है: परिणाम के प्रकार को बदलना। , , , ((), String) , String .

, , . : |(_left, right)| right . , Fn(A) -> B A — , B — .

 fn map<P, F, A, B>(parser: P, map_fn: F) -> impl Fn(&str) -> Result<(&str, B), &str> where P: Fn(&str) -> Result<(&str, A), &str>, F: Fn(A) -> B, { move |input| match parser(input) { Ok((next_input, result)) => Ok((next_input, map_fn(result))), Err(err) => Err(err), } }

? P — . A . F — , P , , P , — B A

parser(input) , , result map_fn(result) , A B , .

, , map , Result :

 fn map<P, F, A, B>(parser: P, map_fn: F) -> impl Fn(&str) -> Result<(&str, B), &str> where P: Fn(&str) -> Result<(&str, A), &str>, F: Fn(A) -> B, { move |input| parser(input) .map(|(next_input, result)| (next_input, map_fn(result))) }

— , «» Haskell , . A , map , A B , B , . Rust, Option , Result , Iterator Future , . : - Rust, , , , , map .

, , : Fn(&str) -> Result<(&str, Output), &str> . , , , , , , , .

, :

 type ParseResult<'a, Output> = Result<(&'a str, Output), &'a str>;

, , , ParseResult<String> . , , Rust . , rustc , , .

'a , , .

. , , . , .

 trait Parser<'a, Output> { fn parse(&self, input: &'a str) -> ParseResult<'a, Output>; }

: parse() , : , , .

, , :

 impl<'a, F, Output> Parser<'a, Output> for F where F: Fn(&'a str) -> ParseResult<Output>, { fn parse(&self, input: &'a str) -> ParseResult<'a, Output> { self(input) } }

, , , Parser , .

, , . map , .

 fn map<'a, P, F, A, B>(parser: P, map_fn: F) -> impl Parser<'a, B> where P: Parser<'a, A>, F: Fn(A) -> B, { move |input| parser.parse(input) .map(|(next_input, result)| (next_input, map_fn(result))) }

: , parser.parse(input) , , P , , Parser , , Parser . , . 'a' , , .

pair , :

 fn pair<'a, P1, P2, R1, R2>(parser1: P1, parser2: P2) -> impl Parser<'a, (R1, R2)> where P1: Parser<'a, R1>, P2: Parser<'a, R2>, { move |input| match parser1.parse(input) { Ok((next_input, result1)) => match parser2.parse(next_input) { Ok((final_input, result2)) => Ok((final_input, (result1, result2))), Err(err) => Err(err), }, Err(err) => Err(err), } }

: parser.parse(input) parser(input) .

, pair , map .

 fn pair<'a, P1, P2, R1, R2>(parser1: P1, parser2: P2) -> impl Parser<'a, (R1, R2)> where P1: Parser<'a, R1>, P2: Parser<'a, R2>, { move |input| { parser1.parse(input).and_then(|(next_input, result1)| { parser2.parse(next_input) .map(|(last_input, result2)| (last_input, (result1, result2))) }) } }

and_then Result map , , Result , Result . match . and_then , , map , left right .

Left Right

pair map , left right :

 fn left<'a, P1, P2, R1, R2>(parser1: P1, parser2: P2) -> impl Parser<'a, R1> where P1: Parser<'a, R1>, P2: Parser<'a, R2>, { map(pair(parser1, parser2), |(left, _right)| left) } fn right<'a, P1, P2, R1, R2>(parser1: P1, parser2: P2) -> impl Parser<'a, R2> where P1: Parser<'a, R1>, P2: Parser<'a, R2>, { map(pair(parser1, parser2), |(_left, right)| right) }

pair , , map , .

, , .

, Parser ParseResult . match_literal :

 fn match_literal<'a>(expected: &'static str) -> impl Parser<'a, ()> { move |input: &'a str| match input.get(0..expected.len()) { Some(next) if next == expected => Ok((&input[expected.len()..], ())), _ => Err(input), } }

, , — &'a str , rustc .

identifier , , , :

 fn identifier(input: &str) -> ParseResult<String> {

. () . .

 #[test] fn right_combinator() { let tag_opener = right(match_literal("<"), identifier); assert_eq!( Ok(("/>", "my-first-element".to_string())), tag_opener.parse("<my-first-element/>") ); assert_eq!(Err("oops"), tag_opener.parse("oops")); assert_eq!(Err("!oops"), tag_opener.parse("<!oops")); }

. < . ? .

, , . , .

, , - , : .

( ) . .

— , <element attribute="value"/> , . , , .

identifier , . , .

 fn one_or_more<'a, P, A>(parser: P) -> impl Parser<'a, Vec<A>> where P: Parser<'a, A>, { move |mut input| { let mut result = Vec::new(); if let Ok((next_input, first_item)) = parser.parse(input) { input = next_input; result.push(first_item); } else { return Err(input); } while let Ok((next_input, next_item)) = parser.parse(input) { input = next_input; result.push(next_item); } Ok((input, result)) } }

, , , A , Vec<A> — A .

identifier . , , . , , .

, : ? :

 fn zero_or_more<'a, P, A>(parser: P) -> impl Parser<'a, Vec<A>> where P: Parser<'a, A>, { move |mut input| { let mut result = Vec::new(); while let Ok((next_input, next_item)) = parser.parse(input) { input = next_input; result.push(next_item); } Ok((input, result)) } }

, , .

 #[test] fn one_or_more_combinator() { let parser = one_or_more(match_literal("ha")); assert_eq!(Ok(("", vec![(), (), ()])), parser.parse("hahaha")); assert_eq!(Err("ahah"), parser.parse("ahah")); assert_eq!(Err(""), parser.parse("")); } #[test] fn zero_or_more_combinator() { let parser = zero_or_more(match_literal("ha")); assert_eq!(Ok(("", vec![(), (), ()])), parser.parse("hahaha")); assert_eq!(Ok(("ahah", vec![])), parser.parse("ahah")); assert_eq!(Ok(("", vec![])), parser.parse("")); }

: one_or_more , , zero_or_more , .

, , . one_or_more zero_or_more , - :

 fn one_or_more<'a, P, A>(parser: P) -> impl Parser<'a, Vec<A>> where P: Parser<'a, A>, { map(pair(parser, zero_or_more(parser)), |(head, mut tail)| { tail.insert(0, head); tail }) }

Rust, cons Vec , , Lisp, , . , : .

, : , . : ( ). , , Clone , , , .

. , one_or_more , , , , , - , , RangeBound : range(0..) zero_or_more , range(1..) one_or_more , range(5..=6) , .

. zero_or_more one_or_more .

, — , Rc ?

, one_or_more zero_or_more .

, . , . , , , > /> . , . , , , , .

. .

-. match_literal , . ? - , Unicode, . Rust, , char is_whitespace , is_alphabetic is_alphanumeric .

-. , , is_whitespace , identifier .

-. , . any_char , char , , pred , , : pred(any_char, |c| c.is_whitespace()) . , , : .

any_char , , UTF-8.

 fn any_char(input: &str) -> ParseResult<char> { match input.chars().next() { Some(next) => Ok((&input[next.len_utf8()..], next)), _ => Err(input), } }

pred , , . , . , true , . , .

 fn pred<'a, P, A, F>(parser: P, predicate: F) -> impl Parser<'a, A> where P: Parser<'a, A>, F: Fn(&A) -> bool, { move |input| { if let Ok((next_input, value)) = parser.parse(input) { if predicate(&value) { return Ok((next_input, value)); } } Err(input) } }

, , :

 #[test] fn predicate_combinator() { let parser = pred(any_char, |c| *c == 'o'); assert_eq!(Ok(("mg", 'o')), parser.parse("omg")); assert_eq!(Err("lol"), parser.parse("lol")); }

, whitespace_char :

 fn whitespace_char<'a>() -> impl Parser<'a, char> { pred(any_char, |c| c.is_whitespace()) }

, whitespace_char , , , , , . space1 space0 .

 fn space1<'a>() -> impl Parser<'a, Vec<char>> { one_or_more(whitespace_char()) } fn space0<'a>() -> impl Parser<'a, Vec<char>> { zero_or_more(whitespace_char()) }

? , , . identifier ( , any_char pred *_or_more ). match_literal("=") = . , . , , .

 fn quoted_string<'a>() -> impl Parser<'a, String> { map( right( match_literal("\""), left( zero_or_more(pred(any_char, |c| *c != '"')), match_literal("\""), ), ), |chars| chars.into_iter().collect(), ) }

, , , , .

map - , , , , , : . map right , right — , : match_literal("\"") . .

right — . left , , left , , , match_literal("\"") — . , — .

pred any_char , , , zero_or_more , :

right left .

, . , zero_or_more ? Vec<A> A . any_char char . , , Vec<char> . map : , Vec<char> String , , String Iterator<Item = char> , vec_of_chars.into_iter().collect() , String .

, , , , , , , , .

 #[test] fn quoted_string_parser() { assert_eq!( Ok(("", "Hello Joe!".to_string())), quoted_string().parse("\"Hello Joe!\"") ); }

, , , , .

,

, , = . , .

. , Vec<(String, String)> , (String, String) , zero_or_more . , .

 fn attribute_pair<'a>() -> impl Parser<'a, (String, String)> { pair(identifier, right(match_literal("="), quoted_string())) }

! : pair , identifier , String , right = , , quoted_string , String .

zero_or_more , , .

 fn attributes<'a>() -> impl Parser<'a, Vec<(String, String)>> { zero_or_more(right(space1(), attribute_pair())) }

: ,
. right .

 #[test] fn attribute_parser() { assert_eq!( Ok(( "", vec![ ("one".to_string(), "1".to_string()), ("two".to_string(), "2".to_string()) ] )), attributes().parse(" one=\"1\" two=\"2\"") ); }

! !

, , rustc , , . , . , rustc, , , #![type_length_limit = "…some big number…"] , . , #![type_length_limit = "16777216"] , . , !

, , , , NP-. element: , , , zero_or_more , ?

, , . , , , : < , . , (String, Vec<(String, String)>) .

 fn element_start<'a>() -> impl Parser<'a, (String, Vec<(String, String)>)> { right(match_literal("<"), pair(identifier, attributes())) }

, , .

 fn single_element<'a>() -> impl Parser<'a, Element> { map( left(element_start(), match_literal("/>")), |(name, attributes)| Element { name, attributes, children: vec![], }, ) }

, , — Element !

 #[test] fn single_element_parser() { assert_eq!( Ok(( "", Element { name: "div".to_string(), attributes: vec![("class".to_string(), "float".to_string())], children: vec![] } )), single_element().parse("<div class=\"float\"/>") ); }

… , .

single_element , , , . , , , — , — .

, , ...

- Rust, , , .

. , :

 enum List<A> { Cons(A, List<A>), Nil, }

rustc , List<A> , List::<A>::Cons List<A> , . rustc, , , .

, Rust. , Rust, , , , . , .

, . , List::Cons A A , A A . , , , , List::Cons , . , Rust — Box .

 enum List<A> { Cons(A, Box<List<A>>), Nil, }

Box , . , , Box<dyn Parser<'a, A>> .

. ? , - , , . : . . , , SIMD ( ).

, Parser Box , .

 struct BoxedParser<'a, Output> { parser: Box<dyn Parser<'a, Output> + 'a>, } impl<'a, Output> BoxedParser<'a, Output> { fn new<P>(parser: P) -> Self where P: Parser<'a, Output> + 'a, { BoxedParser { parser: Box::new(parser), } } } impl<'a, Output> Parser<'a, Output> for BoxedParser<'a, Output> { fn parse(&self, input: &'a str) -> ParseResult<'a, Output> { self.parser.parse(input) } }

, , BoxedParser box . BoxedParser ( BoxedParser , ), BoxedParser::new(parser) , , Box . , Parser , .

Box , BoxedParser Parser , . , , , , , , , , . .

, , , .

, ? , , . quoted_string :

 fn quoted_string<'a>() -> impl Parser<'a, String> { map( right( match_literal("\""), left( zero_or_more(pred(any_char, |c| *c != '"')), match_literal("\""), ), ), |chars| chars.into_iter().collect(), ) }

, . Parser ?

, , impl Trait , impl Trait .

… BoxedParser . , impl Parser<'a, A> , , BoxedParser<'a, A> .

, , , Parser .

map , Parser :

 trait Parser<'a, Output> { fn parse(&self, input: &'a str) -> ParseResult<'a, Output>; fn map<F, NewOutput>(self, map_fn: F) -> BoxedParser<'a, NewOutput> where Self: Sized + 'a, Output: 'a, NewOutput: 'a, F: Fn(Output) -> NewOutput + 'a, { BoxedParser::new(map(self, map_fn)) } }

'a , , . , — , , impl Trait .

quoted_string :

 fn quoted_string<'a>() -> impl Parser<'a, String> { right( match_literal("\""), left( zero_or_more(pred(any_char, |c| *c != '"')), match_literal("\""), ), ) .map(|chars| chars.into_iter().collect()) }

, , .map() right() .

pair , left right , , , , pair . , , map , .

— pred . Parser :

 fn pred<F>(self, pred_fn: F) -> BoxedParser<'a, Output> where Self: Sized + 'a, Output: 'a, F: Fn(&Output) -> bool + 'a, { BoxedParser::new(pred(self, pred_fn)) }

quoted_string pred , :

 zero_or_more(any_char.pred(|c| *c != '"')),

, , , zero_or_more — « any_char », . , zero_or_more one_or_more .

quoted_string , map single_element :

 fn single_element<'a>() -> impl Parser<'a, Element> { left(element_start(), match_literal("/>")).map(|(name, attributes)| Element { name, attributes, children: vec![], }) }

element_start , , , . ...

… , . , .

map pred Box — !

. single_element , , > , /> . , , .

 fn open_element<'a>() -> impl Parser<'a, Element> { left(element_start(), match_literal(">")).map(|(name, attributes)| Element { name, attributes, children: vec![], }) }

, ? , , , zero_or_more , ? , , — : , , .

, , : , , . , , , . , , , , , , .

 fn either<'a, P1, P2, A>(parser1: P1, parser2: P2) -> impl Parser<'a, A> where P1: Parser<'a, A>, P2: Parser<'a, A>, { move |input| match parser1.parse(input) { ok @ Ok(_) => ok, Err(_) => parser2.parse(input), } }

element , , ( open_element , element ).

 fn element<'a>() -> impl Parser<'a, Element> { either(single_element(), open_element()) }

. , , , . , ?

 fn close_element<'a>(expected_name: String) -> impl Parser<'a, String> { right(match_literal("</"), left(identifier, match_literal(">"))) .pred(move |name| name == &expected_name) }

pred , ?

, :

 fn parent_element<'a>() -> impl Parser<'a, Element> { pair( open_element(), left(zero_or_more(element()), close_element(…oops)), ) }

close_element ? , .

. , parent_element , open_element element parent_element , , XML.

, , and_then ? , . and_then : -, , , , . pair , , , , . , and_then Result Option , , , Result Option , , ( , )).

, .

 fn and_then<'a, P, F, A, B, NextP>(parser: P, f: F) -> impl Parser<'a, B> where P: Parser<'a, A>, NextP: Parser<'a, B>, F: Fn(A) -> NextP, { move |input| match parser.parse(input) { Ok((next_input, result)) => f(result).parse(next_input), Err(err) => Err(err), } }

, , P , , A . F , map A B , , and_then A NextP , B . — B , , , NextP .

: , , , , f ( A ), , f(result) , B . . , , , B

: P , , f P , NextP , , .

Parser , map , .

 fn and_then<F, NextParser, NewOutput>(self, f: F) -> BoxedParser<'a, NewOutput> where Self: Sized + 'a, Output: 'a, NewOutput: 'a, NextParser: Parser<'a, NewOutput> + 'a, F: Fn(Output) -> NextParser + 'a, { BoxedParser::new(and_then(self, f)) }

, , ?

, pair :

 fn pair<'a, P1, P2, R1, R2>(parser1: P1, parser2: P2) -> impl Parser<'a, (R1, R2)> where P1: Parser<'a, R1> + 'a, P2: Parser<'a, R2> + 'a, R1: 'a + Clone, R2: 'a, { parser1.and_then(move |result1| parser2.map(move |result2| (result1.clone(), result2))) }

, : parser2.map() parser2 , Fn , FnOnce , parser2 , . , Rust. , , pair .

, Rust, close_element , , .

 fn parent_element<'a>() -> impl Parser<'a, Element> { pair( open_element(), left(zero_or_more(element()), close_element(…oops)), ) }

, and_then , close_element .

 fn parent_element<'a>() -> impl Parser<'a, Element> { open_element().and_then(|el| { left(zero_or_more(element()), close_element(el.name.clone())).map(move |children| { let mut el = el.clone(); el.children = children; el }) }) }

, and_then open_element() , , close_element . , open_element and_then . , Element open_element , , , .

, map , Element ( el ) . clone() , Fn . ( Vec<Element> ) Element , .

, , element , open_element parent_element , , , , !

"" ?

, , map «» Haskell?

and_then — , Rust, , map . flat_map Iterator , , .

— "". Thing<A> , and_then , A Thing , Thing — .

, , Option<A> , , Some(A) None , , Some(A) , Some(B)

. , Future<A> , and_then Future , Future Future<A> , Future<A> . Future<A> , — ¹ , Future . , Future , and_then , Future , . , Future , .

, Rust , , , , , , , . .

, Redux

, XML, . , ( , , < div / > , ).

 fn whitespace_wrap<'a, P, A>(parser: P) -> impl Parser<'a, A> where P: Parser<'a, A>, { right(space0(), left(parser, space0())) }

element , element , , , .

 fn element<'a>() -> impl Parser<'a, Element> { whitespace_wrap(either(single_element(), parent_element())) }

!

, ! , .

 #[test] fn xml_parser() { let doc = r#" <top label="Top"> <semi-bottom label="Bottom"/> <middle> <bottom label="Another bottom"/> </middle> </top>"#; let parsed_doc = Element { name: "top".to_string(), attributes: vec![("label".to_string(), "Top".to_string())], children: vec![ Element { name: "semi-bottom".to_string(), attributes: vec![("label".to_string(), "Bottom".to_string())], children: vec![], }, Element { name: "middle".to_string(), attributes: vec![], children: vec![Element { name: "bottom".to_string(), attributes: vec![("label".to_string(), "Another bottom".to_string())], children: vec![], }], }, ], }; assert_eq!(Ok(("", parsed_doc)), element().parse(doc)); }

, - , , :

 #[test] fn mismatched_closing_tag() { let doc = r#" <top> <bottom/> </middle>"#; assert_eq!(Err("</middle>"), element().parse(doc)); }

, . , , , , . , , , , . , , , , , .

: , ! , , , ² .

, , . !

, , Rust , , - , , , .

, pom , , .

Rust nom , pom ( , ), , .

Rust combine , .

Haskell Parsec .

, « Haskell» , , Haskell.

Bodil Stokke Creative Commons Attribution-NonCommercial-ShareAlike 4.0. , http://creativecommons.org/licenses/by-nc-sa/4.0/ .

1: .

2: , .

andreevlex funkill

जंग के साथ दहनशील पार्सर की खोज

शुरुआत के दृष्टिकोण से

इस लेख के साथ कैसे काम करें

Xcruciating Markup भाषा

Parser परिभाषा;

हमारा पहला पार्सर

पार्सर बनाना

हमारे पार्सर का परीक्षण

कुछ कम विशिष्ट के लिए पार्सर

combinators

फन्नेकार परिचय

Left Right

,

"" ?

, Redux

!

More articles: