🕴🏼 👷🏼 ⤵️ पार्सर कॉम्बीनेटर के साथ सी # में डीएसएल का निर्माण 🥛 📱 🎂

निकोलस ब्लूमहार्ड, एक प्रसिद्ध .NET डेवलपर, ऑटोफैक IoC / DI कंटेनर के लेखक के लेख का अनुवाद। इस लेख में, निकोलस एक वास्तविक दुनिया के उदाहरण के साथ दिखाता है कि कैसे पार्सर-कॉम्बिनेटरों के एक पुस्तकालय स्पार्क का उपयोग करके कम से कम प्रयास के साथ एक विषय-उन्मुख प्रोग्रामिंग भाषा का एक पार्सर लिखना है।

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

उपयोगकर्ता खातों के प्रकार का सेट असीमित है; वर्तमान में यह "कर्मचारी", "ठेकेदार", "अस्थायी कर्मचारी" और इसी तरह है। खाता प्राप्त करने के लिए, उपयोगकर्ता को उपयुक्त फॉर्म भरना होगा।

प्रश्नावली डेटा को इकट्ठा और सहेजते समय, इसकी सामग्री तब तक मायने नहीं रखती है जब तक कि संबंधित जानकारी व्यवस्थापक को प्रस्तुत नहीं की जाती है, जो अंततः आवेदन को स्वीकार या अस्वीकार करता है।

VS2010 के समाधान के रूप में एक उदाहरण के लिए लिंक।

कठिनाइयों

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

प्रोफाइल जमा करने के कई संभावित तरीके हैं:

संबंधित डेटाबेस तालिकाओं के लिए प्रश्नावली का मानचित्र डोमेन मॉडल
XML- आधारित प्रश्नावली प्रारूप बनाएँ
अपनी बहुत सामान्य XAML फ़ाइलों के साथ Windows वर्कफ़्लो फ़ाउंडेशन का उपयोग करें
CSV फ़ाइलों या अन्य तालिकाओं से प्रोफ़ाइल पढ़ें

इन तरीकों में से प्रत्येक में इसके पेशेवरों और विपक्षों को कार्यान्वयन, रखरखाव, सुविधा और लचीलेपन में आसानी होती है।

इस लेख में, हम एक और आकर्षक विकल्प पर विचार करेंगे: प्रोफाइल का वर्णन करने के लिए एक सुविधाजनक मिनी-भाषा बनाना।

प्रोफ़ाइल विवरण भाषा

आपने आंतरिक और बाहरी DSL के बीच अंतर की कुछ चर्चा पढ़ी होगी।

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

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

एक DSL प्रश्नावली का एक उदाहरण इस प्रकार है:

identification "Personal Details" [ name "Full Name" department "Department" ] employment "Current Employer" [ name "Your Employer" contact "Contact Number" #months "Total Months Employed" ]

यह व्यक्तिगत डेटा और रोजगार विवरण एकत्र करने वाला एक दो-चरण प्रश्नावली है।

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

एप्लिकेशन संबंधित प्रकार के खाते से संबंधित प्रश्नावली का विवरण पढ़ेगा, और उपयोगकर्ता के लिए चरण-दर-चरण इंटरफ़ेस प्रस्तुत करेगा।

प्रोफाइल के विवरण के विश्लेषण के लिए दृष्टिकोण

पार्सिंग स्रोत भाषा में पाठ को स्वीकार करने की प्रक्रिया है, जैसे कि ऊपर प्रश्नावली और इसे एक निश्चित प्रतिनिधित्व में परिवर्तित करना, आमतौर पर किसी प्रकार के ऑब्जेक्ट मॉडल में जिसके साथ कार्यक्रम काम कर सकता है। C # प्रोग्रामर के लिए, इसे प्राप्त करने के कई तरीके हैं।

हाथ से लिखे हुए पर्स

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

नियमित अभिव्यक्ति

यह पाठ से पैटर्न को मिलाने और निकालने का एक सुविधाजनक तरीका है। .NET में नियमित रूप से अभिव्यक्ति के साथ कुशलता से काम करने के लिए अंतर्निहित System.Text.Regex वर्ग शामिल है, इसलिए वे आम तौर पर इस बात पर विचार करने के लिए पहला विकल्प होते हैं कि जब किसी को एक पार्सिंग कार्य का सामना करना पड़ता है। इसके काफी सरल व्याकरण के बावजूद, नियमित अभिव्यक्ति जल्दी से पढ़ना और बनाए रखना मुश्किल हो जाता है। यह शायद उनकी सबसे बड़ी कमी है। इसके अलावा, कई व्याकरण हैं जो नियमित अभिव्यक्ति पार्स करने में सक्षम नहीं हैं (उन लोगों के साथ शुरू करना जो घोंसले के शिकार की अनुमति देते हैं)।

पार्सर जनरेटर

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

पार्सर कॉम्बिनेटर

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

शुरुआत हो रही है

आरंभ करने के लिए, Sprache.dll डाउनलोड करें । यह लेख इसलिए आयोजित किया गया है ताकि आप NUnit के साथ Visual Studio में पार्सर बनाकर और उसका परीक्षण करके पाठ का अनुसरण कर सकें।

व्याकरण का निर्माण नीचे से ऊपर तक किया जाता है। पार्सर सबसे पहले निम्न-स्तर के सिंटैक्स तत्वों जैसे कि पहचानकर्ता, तार और संख्या के लिए बनाए जाते हैं। फिर हम धीरे-धीरे ऊंचे उठते हैं, इन सरल भागों को और अधिक जटिल लोगों में मिलाते हैं, जब तक कि हमें पूरी भाषा नहीं मिलती।

आईडी पार्सिंग

प्रोफाइल का वर्णन करने के लिए हमारी भाषा में, सबसे नेस्टेड महत्वपूर्ण तत्व प्रश्न है:

 name "Full Name"

यहाँ के मुख्य भाग पहचानकर्ता और उद्धरण चिह्नों में कुछ पाठ हैं। हमारे पार्सर के लिए पहला कार्य पहचानकर्ता को पार्स करना होगा, इस मामले में 'नाम'।

 [Test] public void AnIdentifierIsASequenceOfCharacters() { var input = "name"; var id = QuestionnaireGrammar.Identifier.Parse(input); Assert.AreEqual("name", id); }

स्पार्स पार्सर स्थिर वर्ग विधियाँ हैं जो व्याकरण का प्रतिनिधित्व करती हैं। प्रश्नावलीग्राममार.पार्सेंट टाइप पार्सर <string> , i.e. यह टाइप स्ट्रिंग के मान लौटाता है।

पार्सर परिभाषा:

 public static readonly Parser<string> Identifier = Parse.Letter.AtLeastOnce().Text().Token();

यह कोड बहुत अच्छी तरह से पढ़ता है - हम अक्षरों के एक गैर-खाली अनुक्रम का विश्लेषण करने और उनके पाठीय प्रतिनिधित्व को वापस करने जा रहे हैं। यहाँ पार्सर के तत्व हैं:

Parse.Letter - Sparche में, Parse वर्ग में सामान्य पार्सिंग कार्य करने के लिए सहायक विधियाँ और गुण होते हैं। पत्र एक साधारण Parser <char> parser है जो इनपुट से एक पत्र पढ़ता है और इसे एक चार के रूप में वापस करता है। यदि इनपुट प्रतीक एक अक्षर नहीं है, तो यह पार्सर उससे मेल नहीं खाएगा।

AtLeastOnce () - स्पार्स समर्थन पुनरावृत्ति का उपयोग करके बनाए गए सभी पार्सर। AtLeastOnce () टाइप T के एक तत्व का एक पार्सर लेता है और एक नया Parser देता है जो ऐसे तत्वों के अनुक्रम को पार्स करेगा, जो एक IEnumerable <T> को लौटाता है।

पाठ () - AtLeastOnce () संशोधक हमारे पार्सर <char> को ले जाता है और इसे Parser <IEnumerable <char >> प्रकार के साथ एक पार्सर में बदल देता है। सहायक फ़ंक्शन टेक्स्ट () प्रकार का पार्सर लेता है Parser <IEnumerable <char >> और अधिक सुविधाजनक काम के लिए इसे Parser <string> में कनवर्ट करता है।

टोकन () एक संशोधक है जो स्वीकार करता है और फिर व्हाट्सएप के अग्रणी और अनुगामी को त्याग देता है।

बस?

पहचानकर्ता पार्सर के लिए कुछ और दिलचस्प परीक्षण हैं।

 [Test] public void AnIdentifierDoesNotIncludeSpace() { var input = "a b"; var parsed = QuestionnaireGrammar.Identifier.Parse(input); Assert.AreEqual(“a”, parsed); }

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

 [Test] public void AnIdentifierCannotStartWithQuote() { var input = "\"name"; Assert.Throws<ParseException>(() => QuestionnaireGrammar.Identifier.Parse(input)); }

यदि पार्सर उपयुक्त नहीं है, तो पार्स () एक्सटेंशन विधि ParseException को फेंकता है। आप गैर-फेंकने वाले TryParse () का भी उपयोग कर सकते हैं।

सही ढंग से पहचाने गए पहचानकर्ता के साथ खुश होने के बाद, हम आगे बढ़ सकते हैं।

उद्धृत पाठ पार्सिंग

पहचान किए गए पाठ को पार्स करने से ज्यादा कठिन नहीं है - हमारा सरल संस्करण बच गए वर्णों या कुछ भी जटिल का समर्थन नहीं करता है।

आइए इनपुट लाइन को फिर से देखें:

 name "Full Name"

उद्धृत पाठ को पार्स करने के लिए, हमें मिलान करना होगा:

उद्धरण चिह्नों को खोलना
अन्य उद्धरण चिह्नों को छोड़कर सब कुछ
उद्धरण चिह्नों को बंद करना

उद्धरण स्वयं हमारे लिए विशेष रूप से दिलचस्प नहीं हैं, इसलिए हम केवल उनके बीच पाठ वापस करेंगे।

पार्सर के लिए परीक्षण इस तरह दिखेगा:

 [Test] public void QuotedTextReturnsAValueBetweenQuotes() { var input = "\"this is text\""; var content = QuestionnaireGrammar.QuotedText.Parse(input); Assert.AreEqual("this is text", content); }

चलो सीधे विश्लेषक के पास जाते हैं:

 public static readonly Parser<string> QuotedText = (from open in Parse.Char('"') from content in Parse.CharExcept('"').Many().Text() from close in Parse.Char('"') select content).Token();

LINQ क्वेरी सिंटैक्स के इस सुविधाजनक पुन: उपयोग को पहली बार F # टीम के ल्यूक होबन द्वारा वर्णित (जहाँ तक मैं जानता हूँ) किया गया था। संचालन से अलग-अलग वाक्यविन्यास इकाइयों को तोड़ते हैं, और उन्हें पूरे पार्सर के रिटर्न मान में बदल देते हैं।

परसिम प्रश्न

आपने देखा होगा कि पार्सर्स दृढ़ता से टाइप किए जाते हैं: एक चरित्र रिटर्न के लिए पार्सर, और टेक्स्ट रिटर्न स्ट्रिंग के लिए पार्सर। प्रश्न के लिए पार्सर प्रश्न लौटाएगा!

 public class Question { public Question(string id, string prompt) { Id = id; Prompt = prompt; } public string Id { get; private set; } public string Prompt { get; private set; } }

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

 public static readonly Parser<Question> Question = from id in Identifier from prompt in QuotedText select new Question(id, prompt);

प्रश्न के लिए इकाई परीक्षण अब गुजरता है:

 [Test] public void AQuestionIsAnIdentifierFollowedByAPrompt() { var input = "name \"Full Name\""; var question = QuestionnaireGrammar.Parse(input); Assert.AreEqual("name", question.Id); Assert.AreEqual("Full Name", question.Prompt); }

धारा पार्सिंग

अनुभाग का विश्लेषण प्रश्न के विश्लेषण के समान है: पहले हम एक शब्दार्थ मॉडल का निर्माण करते हैं, और फिर, मौजूदा पार्सर का उपयोग करते हुए, हम स्रोत पाठ का इसमें अनुवाद करते हैं।

आपको याद दिलाता हूं कि अनुभाग इस तरह दिखता है:

 identification "Personal Details" [ name "Full Name" department "Department" ]

हम इसे इस तरह से ऑब्जेक्ट मॉडल में दर्शा सकते हैं:

 public class Section { public Section(string id, string title, IEnumerable<Question> questions) { Id = id; Title = title; Questions = questions; } public string Id { get; private set; } public string Prompt { get; private set; } public IEnumerable<Question> Questions { get; private set; } }

एक पार्सर का विकास एक वस्तु मॉडल के विकास के रूप में सरल है:

 public static readonly Parser<Section> Section = from id in Identifier from title in QuotedText from lbracket in Parse.Char('[').Token() from questions in Question.Many() from rbracket in Parse.Char(']').Token() select new Section(id, title, questions);

उदाहरण को पूरा करने के लिए, हमारे पास एक और मॉडल वर्ग है:

 public class Questionnaire { public Questionnaire(IEnumerable<Section> sections) { Sections = sections; } public IEnumerable<Section> Sections { get; private set; } }

संबंधित पार्सर (इस समय वाक्यविन्यास को पार्स किए बिना):

 public static Parser<Questionnaire> Questionnaire = Section.Many().Select(sections => new Questionnaire(sections)).End();

.End () संशोधक के लिए आवश्यक है कि सभी इनपुट डेटा पार्स किए जाएं (यानी अंत में कोई कचरा नहीं बचा है)।

यह हम सभी को एक उदाहरण के लिए चाहिए, बिना डेटा प्रकार के क्वालीफायर के।

प्रतिक्रिया डेटा प्रकारों के लिए समर्थन

हमारे व्याकरण का अंतिम स्पर्श उत्तर प्रकार के क्वालिफायर के लिए समर्थन होगा।

 #months "Total Months Employed"

उनका प्रतिनिधित्व करने के लिए, हम सभी संभावित प्रकारों की गणना का उपयोग कर सकते हैं।

 public enum AnswerType { Natural, Number, Date, YesNo }

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

 public static Parser<AnswerType> AnswerTypeIndicator = Parse.Char('#').Return(AnswerType.Natural) .Or(Parse.Char('$').Return(AnswerType.Number)) .Or(Parse.Char('%').Return(AnswerType.Date)) .Or(Parse.Char('?').Return(AnswerType.YesNo));

प्रश्न कक्षा को एक निर्माण पैरामीटर के रूप में उत्तर टाइप करने के लिए संशोधित किया गया है। प्रश्न पार्सर का एक सरल संशोधन हमारे काम को पूरा करता है।

 public static Parser<Question> Question = from at in AnswerTypeIndicator.Or(Parse.Return(AnswerType.Text)) from id in Identifier from prompt in QuotedText select new Question(id, prompt, at);

सारांश

एक पूर्ण विश्लेषक कोड के 25 अच्छी तरह से गठित लाइनों में सिर्फ छह नियम हैं।

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

पार्सर कॉम्बीनेटर के साथ सी # में डीएसएल का निर्माण