प्रेरणा

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

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

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

मुझे उम्मीद है कि यह किसी को अमूर्तता के डर को दूर करने में मदद करता है और उन्हें सिखाता है कि उन्हें उचित रूप से कैसे उपयोग किया जाए (हाँ, मुझे अभी भी लगता है कि यह कभी-कभी साइकिल लिखने के लिए अधिक कुशल होता है)।

मेरे पास एक लेख से खरोंच से हास्केल पाठ्यक्रम बनाने का कोई उद्देश्य और इच्छा नहीं है, इसलिए मुझे लगता है कि पाठक वाक्य रचना और स्वतंत्र रूप से विकसित सरल कार्यक्रमों से परिचित है। बस मामले में, मैं कार्यान्वयन के विवरण पर आगे बढ़ने से पहले संक्षेप में टाइप कक्षाओं के बारे में बात करूंगा।

उन लोगों के लिए, जिन्होंने हास्केल को कभी नहीं लिखा है, लेकिन यह समझना चाहते हैं कि यहां क्या हो रहा है, मैं आपको सलाह देता हूं कि आप सबसे पहले सीखें X को Y मिनट में संबंधित पृष्ठ पर देखें। शुरुआती लोगों के लिए एक उत्कृष्ट रूसी भाषा की पुस्तक के रूप में, मैं डेनिस शेवचेंको द्वारा "ह्यूस बीइंग ए ह्यूमन बीइंग " के बारे में सलाह देता हूं।

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

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

कक्षाएं टाइप करें

हास्केल प्रकार की कक्षाओं का सी ++ और अन्य वस्तु-उन्मुख भाषाओं में कक्षाओं से कोई लेना-देना नहीं है। यदि हम OOP के साथ एक सादृश्य आकर्षित करते हैं, तो टाइप कक्षाएं अधिक तरीकों और कार्यों के अधिभार की तरह होती हैं।

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

मानक प्रकार की कक्षाओं के एक सेट के लिए (जैसे कि Eq , Show , Read ...), आप कंपाइलर को टाइप का निर्धारण करने के बाद deriving कीवर्ड का उपयोग करके मानक तरीके से आवश्यक कार्यक्षमता को लागू करने के लिए कह सकते हैं:

 data Point = Point { xCoord :: Float , yCoord :: Float } deriving (Eq, Show)

आप अपने स्वयं के प्रकारों को परिभाषित कर सकते हैं:

 class PrettyPrint a where pPrint :: a -> String

यहाँ PrettyPrint वर्ग का नाम है, एक प्रकार का चर है। where कीवर्ड को तथाकथित वर्ग विधियों की सूची के बाद, अर्थात् ऐसे कार्य जो इस वर्ग से टाइप की वस्तुओं पर लागू किए जा सकते हैं।

किसी वर्ग को डेटा प्रकार से संबंधित इंगित करने के लिए, निम्न निर्माण का उपयोग किया जाता है:

 instance PrettyPrint Point where pPrint (Point xy) = "(" ++ show x ++ ", " ++ show y ++ ")"

भाषा आपको उन प्रकार के वर्गों पर प्रतिबंध निर्दिष्ट करने की अनुमति देती है जिनसे फ़ंक्शन तर्क से संबंधित होना चाहिए:

 showVsPretty :: (Show a, PrettyPrint a) => a -> (String, String) showVsPretty x = (show x, pPrint x)

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

 >>> showVsPretty (Point 2 3) ("Point {xCoord = 2.0, yCoord = 3.0}","(2.0, 3.0)") >>> showVsPretty "str" error: No instance for (PrettyPrint [Char]) arising from a use of 'showVsPretty'

कार्यान्वयन

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

पार्सर के संचालन के एक परिणाम का वर्णन करने के लिए दो तत्वों (String, a) उपयुक्त है, जहां एक प्रकार का चर है जो किसी भी उपयोगकर्ता प्रकार को निरूपित कर सकता है।

चूंकि पार्सर कुछ नियमों के अनुसार स्ट्रिंग को पार्स करता है, हम इसे एक फ़ंक्शन के रूप में वर्णित करते हैं जो इनपुट के रूप में एक स्ट्रिंग लेता है और परिणामों की सूची लौटाता है:

 newtype Parser a = Parser { unParser :: String -> [(String, a)] }

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

 parseString :: String -> Parser a -> Maybe a parseString s (Parser p) = case (ps) of [("", val)] -> Just val _ -> Nothing

साधारण पार्सर

हम कई सरल पार्सर लागू करते हैं, जो तब अधिक जटिल संयोजनों के निर्माण में काम आएंगे।

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

 predP :: (Char -> Bool) -> Parser Char predP p = Parser f where f "" = [] f (c : cs) | pc = [(cs, c)] | otherwise = []

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

 charP :: Char -> Parser Char charP char = predP (\c -> c == char)

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

 stringP :: String -> Parser String stringP s = Parser f where fs' | s == s' = [("", s)] | otherwise = []

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

 skip :: (Char -> Bool) -> Parser () skip p = Parser (\s -> [(dropWhile ps, ())])

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

 prefixP :: String -> Parser String prefixP s = Parser f where f input = if s `isPrefixOf` input then [(drop (length s) input, s)] else [] skipString :: String -> Parser () skipString s = Parser f where f input = if s `isPrefixOf` input then [(drop (length s) input, ())] else []

थोड़ी देर बाद हम बाद के फ़ंक्शन के एक सरल कार्यान्वयन पर विचार करेंगे और कोड दोहराव से छुटकारा पाएंगे।

एक मज़ेदार के रूप में पार्सर

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

इस प्रकार की कक्षा को fmap कहा जाता है; कक्षा में एक fmap विधि होती है:

 class Functor f where fmap :: (a -> b) -> fa -> fb

मान लीजिए कि हम पहले से ही एक निश्चित प्रकार की वस्तुओं में तार को पार्स करने का तरीका जानते हैं, और, इसके अलावा, हम जानते हैं कि टाइप b की वस्तुओं को टाइप b की वस्तुओं में कैसे परिवर्तित किया जाए। क्या यह कहना संभव है कि तब टाइप b की वस्तुओं के लिए एक पार्सर है?

यदि एक फ़ंक्शन के रूप में व्यक्त किया जाता है, तो इसके निम्न प्रकार होंगे:

 (a -> b) -> Parser a -> Parser b

यह प्रकार fmap फ़ंक्शन के प्रकार के साथ मेल खाता है, तो चलिए पार्सर को एक fmap बनाने की कोशिश करते हैं। आइए खरोंच से टाइप b के मूल्यों का एक पार्सर बनाएं, जो पहले पार्सर (हम पहले से ही एक है) को कॉल करेगा, और फिर फ़ंक्शन को इसके पार्सिंग के परिणामों पर लागू करेगा।

 instance Functor Parser where fmap :: (a -> b) -> Parser a -> Parser b fmap f (Parser p1) = Parser p2 where p2 :: String -> [(String, b)] p2 s = convert (p1 s) convert :: [(String, a)] -> [(String, b)] convert results = map (\(s, val) -> (s, f val)) results

fmap फंक्शन का एक सुविधाजनक fmap fx == f <$> x पर्यायवाची शब्द है: fmap fx == f <$> x ।

यदि हम किसी फ़ंक्शन का उपयोग एक ऐसे तर्क के रूप में करते हैं, जो अपने पहले तर्क को नए मान के साथ बदल देता है, तो हमें एक और उपयोगी ऑपरेशन मिलता है जो पहले से ही सभी फ़ंक्शंस के लिए दो उदाहरणों में भी लागू होता है (वे केवल तर्क के क्रम में भिन्न होते हैं):

 (<$) :: Functor f => a -> fb -> fa ($>) :: Functor f => fa -> b -> fb

उस पार्सर को याद रखें जो एक विशिष्ट रेखा को skipString ( skipString )? अब आप इसे इस प्रकार लागू कर सकते हैं:

 skipString :: String -> Parser () skipString s = () <$ prefixP s

पार्सर संयोजन

हास्केल में, सभी फ़ंक्शन डिफ़ॉल्ट रूप से करी जाती हैं और आंशिक रूप से उपयोग करने योग्य होती हैं। इसका मतलब यह है कि n तर्कों का एक कार्य वास्तव में एक तर्क का एक कार्य है, जो n-1 तर्कों का एक फ़ंक्शन लौटाता है:

 cons :: Int -> [Int] -> [Int] cons = (:) cons1 :: [Int] -> [Int] cons1 = cons 1 --  cons

हम fmap का उपयोग करके पार्सर के अंदर कुछ मानों के लिए तीन तर्कों से एक फ़ंक्शन लागू करते हैं। प्रकार निम्नानुसार होंगे:

 f :: c -> a -> b p :: Parser c (fmap fp) :: Parser (a -> b)

फ़ंक्शन पार्सर निकला! बेशक, एक स्थिति संभव है जब फ़ंक्शन का प्रतिनिधित्व वास्तव में इनपुट लाइन में होता है, लेकिन मैं इस फ़ंक्शन का उपयोग करने में सक्षम होना चाहूंगा, या पार्सर को प्राप्त करने के लिए Parser b Parser (a -> b) और Parser a पार्सर को संयोजित कर सकता हूं:

 applyP :: Parser (a -> b) -> Parser a -> Parser b

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

 applyP :: Parser (a -> b) -> Parser a -> Parser b applyP (Parser p1) (Parser p2) = Parser f where fs = [ (sx, fx) | (sf, f) <- p1 s, -- p1     (sx, x) <- p2 sf] -- p2   ,

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

 class Functor f => Applicative f where pure :: a -> fa (<*>) :: f (a -> b) -> fa -> fb instance Applicative Parser where pure x = Parser (\s -> [(s, x)]) pf <*> px = Parser (\s -> [ (sx, fx) | (sf, f) <- unParser pf $ s, (sx, x) <- unParser px $ sf])

applyP फंक्शन Applicative क्‍लास से <*> है। इस वर्ग से संबंधित प्रकारों को आवेदक फंक्शंस कहा जाता है।

आवेदक के लिए, दो सहायक कार्य कार्यान्वित किए जाते हैं जो हमारे लिए उपयोगी होंगे:

 (*>) :: fa -> fb -> fb (<*) :: fa -> fb -> fa

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

<$> और <*> मिलाकर, आप बहुत सुविधाजनक डिज़ाइन बना सकते हैं। निम्नलिखित डेटा प्रकार पर विचार करें:

 data MyStructType = MyStruct { field1 :: Type1 , field2 :: Type2 , field3 :: Type3 }

मूल्यों का निर्माण MyStruct भी एक फ़ंक्शन है, इस मामले में यह Type1 -> Type2 -> Type3 -> MyStructType । आप किसी अन्य फ़ंक्शन के साथ ही निर्माता के साथ काम कर सकते हैं। मान लीजिए कि पार्सर पहले से ही संरचना क्षेत्रों के प्रकारों के लिए लिखे गए हैं:

 parser1 :: Parser Type1 parser2 :: Parser Type2 parser3 :: Parser Type3

fmap फ़ंक्शन का उपयोग करते fmap , आप आंशिक रूप से इन पार्सर में से पहले MyStruct को लागू कर सकते हैं:

 parserStruct' :: Parser (Type2 -> Type3 -> MyStructType) parserStruct' = MyStruct <$> parser1

आइए उस फ़ंक्शन को लागू करने का प्रयास करें जो अब पार्सर के "अंदर" है। ऐसा करने के लिए, आपको पहले से ही <*> का उपयोग करना होगा:

 parserStruct'' :: Parser (Type3 -> MyStructType) parserStruct'' = parserStruct' <*> parser2 parserStruct :: Parser MyStructType parserStruct = parserStruct'' <*> parser3

नतीजतन, हमें पूरी संरचना के लिए एक पार्सर मिला (ज़ाहिर है, यहां हम इस धारणा का उपयोग करते हैं कि मूल पंक्ति में इसके क्षेत्रों का प्रतिनिधित्व एक पंक्ति में है)। एक ही काम एक लाइन में किया जा सकता है:

 parserStruct :: Parser MyStructType parserStruct = MyStruct <$> parser1 <*> parser2 <*> parser3

इस तरह के निर्माण अक्सर उपयोग के मामलों में सामना किए जाएंगे।

अब मान लें कि हम एक ऐसा पार्सर लिखने की कोशिश कर रहे हैं जो सरल अंकगणितीय अभिव्यक्तियों को पूर्ण करता है जिसमें पूर्णांक और पहचानकर्ता ऑपरेंड के रूप में मौजूद हो सकते हैं। आइए उनके लिए एक अलग प्रकार का Operand :

 data Operand = IntOp Int | IdentOp String

यदि हम पहले से ही पूर्णांक और पहचानकर्ता (उदाहरण के लिए, C) को पार्स करना जानते हैं, तो हमें ऑपरेंड के लिए एक पार्सर की आवश्यकता है जो एक या दूसरे को पार्स कर सके। यह पार्सर अन्य दो से एक विकल्प है, इसलिए हमें एक फ़ंक्शन की आवश्यकता है जो पार्सर्स को संयोजित कर सकती है ताकि उनके काम के परिणाम संयुक्त हों। पार्सर का परिणाम एक सूची है, और सूचियों का संयोजन उनका संयोजन है। हम दो पार्सर्स को मिलाकर altP फ़ंक्शन को कार्यान्वित करते हैं:

 altP :: Parser a -> Parser a -> Parser a altP (Parser p1) (Parser p2) = Parser (\s -> p1 s ++ p2 s)

तब ऑपरेंड पार्सर को इस फ़ंक्शन का उपयोग करके लागू किया जा सकता है (यहां यह माना जाता है कि parserInt और parserIdent पहले से कहीं वर्णित हैं:

 parserOperand :: Parser Operand parserOperand = altP parserIntOp parserIdentOp where parserIntOp = IntOp <$> parserInt parserIdentOp = IdentOp <$> parserIdent

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

 class Applicative f => Alternative f where empty :: fa (<|>) :: fa -> fa -> fa instance Alternative Parser where empty = Parser (const []) px <|> py = Parser (\s -> unParser px s ++ unParser py s)

ऑपरेशन <|> केवल infix संकेतन में altP फ़ंक्शन है, जो एक पंक्ति में कई पार्सर्स को मिलाकर उपयोग करने के लिए अधिक सुविधाजनक है।

इस वर्ग के सभी प्रकारों के लिए, दो कार्य कार्यान्वित किए जाते हैं, some और many प्रकार के fa -> f [a] । उनमें से प्रत्येक को दूसरे के माध्यम से व्यक्त किया जा सकता है:

 some v = (:) <$> v <*> many v many v = some v <|> pure []

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

उदाहरण का उपयोग करें

अब हम अपने स्वयं के पार्सर लिखने के लिए तैयार हैं, उदाहरण के लिए, निम्नलिखित व्याकरण के साथ सरल अंकगणितीय अभिव्यक्तियों के लिए:

  expr ::= constExpr | binOpExpr | negExpr const ::= int int ::= digit{digit} digit ::= '0' | ... | '9' binOpExpr ::= '(' expr ' ' binOp ' ' expr ')' binOp ::= '+' | '*' negExpr ::= '-' expr

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

सही अभिव्यक्ति लेखन के उदाहरण:

 "123" "-(10 + 42)" "(1 + ((2 + 3) * (4 + 5)))"

गलत प्रविष्टियों के उदाहरण:

 " 666 " "2 + 3" "(10 * 10)"

हम आवश्यक डेटा प्रकार (अभिव्यक्ति और बाइनरी ऑपरेशन) की घोषणा करते हैं:

 data Expr = ConstExpr Int | BinaryExpr Expr Operator Expr | NegateExpr Expr data Operator = Add | Mul

आप पार्स करना शुरू कर सकते हैं! अभिव्यक्ति में ही तीन विकल्प होते हैं। तो हम लिखते हैं:

 -- expr ::= constExpr | binOpExpr | negExpr exprParser :: Parser Expr exprParser = constParser <|> binParser <|> negParser

एक स्थिरांक एक पूर्णांक है। हमारे डेटा प्रकार में, यह कंस्ट्रक्टर में "लिपटे" है, इसलिए हम सीधे पूर्णांक के लिए पार्सर का उपयोग नहीं कर सकते हैं, लेकिन हम वांछित प्रकार के मूल्य को प्राप्त करने के लिए fmap का उपयोग कर सकते हैं।

 -- const ::= int constParser :: Parser Expr constParser = ConstExpr <$> intParser

एक पूर्णांक, व्याकरण के अनुसार, संख्याओं के गैर-रिक्त अनुक्रम के रूप में दर्शाया जाता है। एक अंक को पार्स करने के लिए, हम सहायक फ़ंक्शन predP उपयोग करते हैं और Data.Char मॉड्यूल से Data.Char को Data.Char । अब, अंकों के अनुक्रम को पार्स करने के लिए पार्सर बनाने के लिए, हम फ़ंक्शन का उपयोग some ( many नहीं, क्योंकि कम से कम एक अंक होना चाहिए)। इस तरह के एक पार्सर का परिणाम सभी संभव पार्सिंग विकल्पों की एक सूची देता है, जो सबसे लंबे रिकॉर्ड के साथ शुरू होता है। उदाहरण के लिए, यदि इनपुट स्ट्रिंग "123ab" है, तो परिणामों की सूची इस प्रकार होगी: [("ab", "123"), ("3ab", "12"), ("23ab", "1")] । हमें अंकों के सबसे लंबे अनुक्रम को पार्स करने और इसे Int टाइप करने के लिए परिवर्तित करने की आवश्यकता है। पूरा कार्यान्वयन इस प्रकार है:

 -- int ::= digit{digit} -- digit ::= '0' | ... | '9' intParser :: Parser Int intParser = Parser $ \s -> let res = unParser (some digitParser) s in case res of [] -> [] ((rest, i) : xs) -> [(rest, read i)] where digitParser = predP isDigit

एक अभिव्यक्ति लिखने का अगला तरीका एक बाइनरी ऑपरेशन का उपयोग करना है। व्याकरण के अनुसार, उद्घाटन ब्रैकेट में पहले ब्रैकेट, पहला ऑपरेंड, स्पेस, ऑपरेशन सिंबल, दूसरा स्पेस, दूसरा ऑपरेंड और क्लोजिंग ब्रैकेट शामिल होना चाहिए। व्यक्तिगत पात्रों (कोष्ठक और रिक्त स्थान) को पार्स करने के लिए हम charP फ़ंक्शन का उपयोग करते हैं। exprParser भाव हैं, और उन्हें पार्स करने के लिए पहले से ही एक पार्सर ( exprParser ) है। बाइनरी ऑपरेशन प्रतीक को पार्स करने के लिए, हम नीचे दिए गए सहायक पार्सर का वर्णन करते हैं। यह पार्सर्स के इस सेट को बड़े करीने से संयोजित करता है। शुरुआत में और अभिव्यक्ति के अंत में कोष्ठक होना चाहिए: आपको इसकी जांच करने की आवश्यकता है, लेकिन परिणाम को स्वयं ही छोड़ दें। ऐसा करने के लिए, *> और <* उपयोग करें:

 binParser :: Parser Expr binParser = charP '(' *> ??? <* charP ')'

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

 BinaryExpr <$> exprParser --   <*> (charP ' ' *> binOpParser <* charP ' ') -- ,   <*> exprParser --

हम प्रश्नवाचक चिन्ह के बजाय इस अभिव्यक्ति को प्रतिस्थापित करते हैं:

 -- binOpExpr ::= '(' expr ' ' binOp ' ' expr ')' binParser :: Parser Expr binParser = charP '(' *> (BinaryExpr <$> exprParser <*> (charP ' ' *> binOpParser <* charP ' ') <*> exprParser ) <* charP ')'

एक बाइनरी ऑपरेशन या तो + वर्ण है जो Add मान को पार्स करता है, या * जो Mul पार्स करता है:

 -- binOp ::= '+' | '*' binOpParser :: Parser Operator binOpParser = plusParser <|> multParser where plusParser = charP '+' $> Add multParser = charP '*' $> Mul

व्याकरण का सबसे सरल हिस्सा क्या है, अभिव्यक्ति का निषेध। एक प्रतीक के साथ - कोष्ठक और रिक्त स्थान के साथ भी ऐसा ही करते हैं। इसके बाद, पुनरावर्ती पार्सिंग के परिणाम के लिए NegateExpr कंस्ट्रक्टर लागू करें:

 -- negExpr ::= '-' expr negParser = charP '-' *> (NegateExpr <$> exprParser)

तो, पार्सर के सभी भागों को लागू किया जाता है। कोड एक व्याकरण की तरह है और पूरी तरह से संरचना में इसके साथ मेल खाता है।

स्रोत कोड GitLab: https://gitlab.com/fierce-katie/applicative-parsers-demo पर उपलब्ध है।

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

 $ stack build $ stack exec demo-parser

जो लोग अपने दम पर आगे अभ्यास करना चाहते हैं, उनके लिए मैं निम्नलिखित सलाह दे सकता हूं:

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

आपका ध्यान के लिए धन्यवाद!

हास्केल एप्लायसिव पर्सर्स