टेम्पलेट हास्केल का परिचय। भाग 2. कोड उपकरण का हवाला देते हुए

यह पाठ बुलैट जिगंशिन द्वारा लिखित टेम्प्लेट हास्केल प्रलेखन का अनुवाद है। संपूर्ण पाठ का अनुवाद धारणा को सुविधाजनक बनाने के लिए कई तार्किक भागों में विभाजित किया गया है। पाठ में आगे के इटैलिक्स अनुवादक के नोट्स हैं। अन्य भागों:

• भाग 1. आवश्यक न्यूनतम
• भाग 3. टीएच के अन्य पहलू

प्रशस्ति पत्र मोनाड

चूँकि टेम्पलेट्स को Q मोनड में लिपटे अपने मूल्यों को वापस करना होगा, इसके लिए सहायक कार्यों का एक सेट है जो " lamE " ( Q में लपेटें) lamE , Lit , Pat : lamE ( LamE । LamE ), varE , appE , varP , आदि के varP । घ। उनके हस्ताक्षरों में, फिर से उठाए गए प्रकारों का भी उपयोग किया जाता है: ExpQ = Q Exp , LitQ = Q Lit , PatQ = Q Pat ... (ये सभी Language.Haskell.TH.Lib मॉड्यूल में पाए जा सकते हैं)। इन फ़ंक्शंस का उपयोग करके, आप कोड को कम कर सकते हैं, कम-से-कम अक्सर सिंटैक्स का उपयोग करके।
TH में एक lift फ़ंक्शन भी होता है जो Lift वर्ग के किसी भी प्रकार के Q Exp को बढ़ाता है।
कुछ दुर्लभ मामलों में, आपको एक अद्वितीय नाम उत्पन्न करने की आवश्यकता नहीं हो सकती है, बल्कि बाहरी (टेम्पलेट टेम्पलेट के सापेक्ष) कोड से सटीक पहचानकर्ता नाम का उपयोग कर सकते हैं। इन उद्देश्यों के लिए, एक शुद्ध (शुद्ध) फ़ंक्शन है mkName ∷ String → Name । एक सहायक फ़ंक्शन dyn s = return (VarE (mkName s)) , जो दिए गए नाम ( dyn ∷ String → Q Exp ) के साथ एक चर का प्रतिनिधित्व करने वाला एक Exp मान देता है।

कोष्ठक का उद्धरण

बिल्डिंग Exp वैल्यू एक अमूर्त सिंटैक्स ट्री का प्रतिनिधित्व करता है जो समय लेने वाली और उबाऊ काम है। लेकिन सौभाग्य से, टेम्प्लेट हास्केल में ऐसे कोष्ठक उद्धृत किए गए हैं जो एक विशिष्ट हास्केल कोड को एक संरचना में बदलते हैं।
वे चार प्रकार के होते हैं:

• [e| … |] [e| … |] या [| … |] [| … |] अभिव्यक्ति के लिए ( ∷ Q Exp )
• [d| … |] [d| … |] घोषणाओं के लिए ( ∷ Q [Dec] )
• [t| … |] [t| … |] प्रकारों के लिए ( ∷ Q Type )
• [p| … |] [p| … |] पैटर्न के लिए ( ∷ Q Pat )

तदनुसार, ब्रैकेट के अंदर एक वाक्यविन्यास सही अभिव्यक्ति / घोषणा / प्रकार / पैटर्न होना चाहिए।
उदाहरण के लिए उद्धरण [| λ _ → 0 |] [| λ _ → 0 |] एक संरचना है (return $ LamE [WildP] (LitE (IntegerL 0))) । उद्धरण Q Exp (और न केवल Exp ) का है, इसलिए इसे प्रशस्ति पत्र मोनाड के अंदर गणना की जानी चाहिए, जो टेम्पलेट हास्केल को उद्धरण के अंदर दिखाई देने वाले सभी पहचानकर्ताओं को newName साथ उत्पन्न करने की newName । उदाहरण के लिए, उद्धरण [| λx → x |] [| λx → x |] को निम्नलिखित कोड में परिवर्तित किया जाएगा:

 do id ← newName "x" return $ LamE [VarP id] (VarE id) 

इसके अलावा, उद्धृत कोष्ठक के अंदर, हम ग्लूइंग (स्प्लिसिंग) का उपयोग कर सकते हैं, इसलिए यह पता चलता है कि TH एक मैक्रो प्रीप्रोसेसर के रूप में कार्य करता है जो स्पष्ट रूप से लिखे गए कोड के हिस्से और उत्पन्न भाग को संसाधित करता है। उदाहरण के लिए, उद्धरण [| 1 + $(fx) |] [| 1 + $(fx) |] गणना [| 1 + $(fx) |] (fx) , जो टाइप Q Exp का होना चाहिए, एक्सप्रेशन (टाइप Exp की संरचना), जिसके परिणामस्वरूप परिणाम एक सामान्य हास्केल कोड के रूप में प्रस्तुत किया जाएगा और इसे $(fx) स्थान पर प्रतिस्थापित ( पेस्ट ) किया जाएगा, और फिर उद्धरण जारी रखें - परिणामी कोड को एक संरचना में परिवर्तित करना जो इसका प्रतिनिधित्व करता है। स्वचालित नामकरण के लिए धन्यवाद (वास्तव में, इसके लिए, Q मोनड के अंदर सब कुछ किया जाता है) , बोली के अंदर एक ही कोड के विभिन्न आवेषणों के बीच स्थानीय चर नामों का कोई टकराव नहीं होगा। निम्नलिखित परिभाषा यह अच्छी तरह से प्रदर्शित करती है:

 summ ∷ Int → Q Exp summ n = summ' n [| 0 |] summ' ∷ Int → Q Exp → Q Exp summ' 0 code = code summ' n code = [| λx → $(summ' (n-1) [| $code + x |]) |] 

यह टेम्प्लेट उन मापदंडों के साथ एक लैम्ब्डा एक्सप्रेशन उत्पन्न करता है जो उन्हें बोता है। उदाहरण के लिए, $(summ 3) को (λx1 → λx2 → λx3 → 0 + x1 + x2 + x3) $(summ 3) परिवर्तित किया $(summ 3) । कृपया ध्यान दें कि उत्पन्न कोड नेस्टेड लैम्ब्डा अभिव्यक्तियों के तर्कों के लिए अलग-अलग पहचानकर्ताओं का उपयोग करता है, हालांकि टेम्पलेट का नाम समान है: [| λx → … |] [| λx → … |] | जैसा कि इस उदाहरण में देखा जा सकता है, उद्धरण और लेबल का घोंसला कोई भी हो सकता है, लेकिन यह महत्वपूर्ण है कि वे वैकल्पिक रूप से - आप उद्धरण के अंदर और पेस्ट के अंदर उद्धरण नहीं कर सकते।
हास्केल कार्यक्रमों का प्रतिनिधित्व करने के लिए इस तरह के "अर्ध-उद्धरण" एक सुविधाजनक तरीका है। और इसकी कुछ सीमाएँ हैं: एक चर की प्रत्येक घटना उस मान से जुड़ी होती है जो तब तक उपलब्ध गुंजाइश में होता है जब तक कि टेम्पलेट्स का विस्तार नहीं हो जाता। इस नियम के तीन मामले हैं:

1. कोष्ठक को उद्धृत करते हुए एक से दूसरे उद्धरण में उपयोग किए गए स्थानीय चर के "कैप्चर" पर रोक लगाते हैं (जैसे एक नियमित हास्केल कार्यक्रम में, आप इसके बाहर क्लोजर चर का उपयोग नहीं कर सकते हैं)। यह पहचानकर्ताओं के पूर्वोक्त स्वचालित एकीकरण के कारण है। उद्धरण केवल [p| … |] [p| … |] उन चर का नाम नहीं बदलता है जो उत्पन्न पैटर्न में प्रवेश करता है (चूंकि ये चर पैटर्न के साथ जुड़े होंगे और यदि उनके पास नए मनमाने नाम हैं, तो यह स्पष्ट नहीं है कि उन्हें कैसे एक्सेस किया जाए) ।
2. कोटेशन में प्रयुक्त वैश्विक पहचानकर्ता, वातावरण में उपलब्ध सभी आवश्यक पहचानकर्ता, जहां उद्धरण परिभाषित किया गया है (फिर से, सामान्य हास्केल में) का उपयोग किया जाता है, इसलिए उद्धरण के मूल्य का उपयोग उन अन्य मॉड्यूल में समस्याओं के बिना किया जा सकता है जिनकी इन सभी आंतरिक परिभाषाओं तक पहुंच नहीं है। या यहां तक ​​कि समान पहचानकर्ताओं के लिए उनकी अपनी परिभाषाएं हैं। यह नियम अन्य मॉड्यूल से प्रतीक के संदर्भ के लिए आंतरिक जीएचसी तंत्र का उपयोग करता है (जो कि उन्हें योग्य बनाता है) । उदाहरण के लिए, उद्धरण [| map |] [| map |] को " GHC.Base.map " में बदल दिया जाएगा, और [t| [String] → Bool |] [t| [String] → Bool |] को " [GHC.Base.String] → GHC.Bool.Bool " [t| [String] → Bool |] बदल दिया गया है। यदि आपको उस क्षेत्र से पहचानकर्ताओं की आवश्यकता है जिसमें टेम्पलेट चिपकाया जाएगा, तो उनके लिए $(dyn "…") रैपर का उपयोग करें। यह समझा जाना चाहिए कि इस तरह से आप गलती से किसी और के द्वारा स्थानीय रूप से परिभाषित पहचानकर्ता का उपयोग कर सकते हैं और एक संघर्ष उत्पन्न होगा या टेम्पलेट उस कोड को उत्पन्न नहीं करेगा जो अपेक्षित है, इसलिए dyn लिए प्रलेखन का कहना है कि यह एक स्वच्छ कार्य नहीं है।
3. इसके अलावा, कोष्ठक के उद्धरण के अंदर, आप स्थानीय फ़ंक्शन चर का उपयोग कर सकते हैं। संकलन के चरण में, ये चर (बस संबंधित पहचानकर्ता) हैं, लेकिन रनटाइम पर, वे सिर्फ स्थिरांक हैं, इसलिए TH उनके स्थान पर संबंधित मानों को प्रतिस्थापित कर देगा। तो, एक्सप्रेशन let x = 5 in [| … x … |] let x = 5 in [| … x … |] को let x = 5 in [| … $(lift x) … |] let x = 5 in [| … $(lift x) … |] - अर्थात, आपको Q Exp प्रकार में स्थानीय चर के पहचानकर्ता को मैन्युअल रूप से लपेटने की आवश्यकता नहीं है ।

चिपकाना और उद्धृत करना पारस्परिक रूप से उलटा ऑपरेशन है: एक Exp संरचना को हास्केल कोड में बदल देता है, और दूसरा हास्केल कोड को एक Exp स्ट्रक्चर में बदल देता है, इसलिए वे पारस्परिक रूप से सर्वनाश करते हैं:

 $( [|  |] ) ≡  [| $(  ) |] ≡  

यह आपको केवल TH प्रोग्राम विकसित करते समय उत्पन्न हास्केल कोड के संदर्भ में सोचने की अनुमति देता है, और इसके सिंटैक्स का प्रतिनिधित्व करने वाली आंतरिक संरचनाओं के बारे में नहीं सोचना चाहिए।
उदाहरण के लिए, " $(summ 3) " की गणना $(summ 3) । हम इसकी परिभाषा के साथ टेम्पलेट के उपयोग को बदल देंगे:

  $(summ 3) $(summ' 3 [| 0 |]) $([| λx → $(summ' (3-1) [| $([| 0 |]) + x |]) |]) 

अब हम अतिरिक्त ब्रैकेट $([| … |]) को हटा सकते हैं, एक अद्वितीय पहचानकर्ता के साथ " x " को बदल सकते हैं:

  λx1 → $(summ' (3-1) [| 0 + x1 |]) 

योग की परिभाषा को फिर से summ' :

  λx1 → $([| λx → $(summ' (2-1) [| $([| 0 + x1 |]) + x |]) |]) 

अगला, हम अंतिम दो चरणों को तब तक दोहराएंगे जब तक यह संभव न हो:

  λx1 → λx2 → $( summ' (2-1) [| 0 + x1 + x2 |] ) λx1 → λx2 → $([| λx → $(summ' (1-1) [| $([| 0 + x1 + x2 |]) + x |]) |]) λx1 → λx2 → λx3 → $(summ' (1-1) [| 0 + x1 + x2 + x3 |]) λx1 → λx2 → λx3 → $( [| 0 + x1 + x2 + x3 |]) λx1 → λx2 → λx3 → 0 + x1 + x2 + x3 

दिलचस्प बात यह है कि इस परिभाषा में, लैम्ब्डा अभिव्यक्ति ( λx1 → λx2 → … ) के बाईं ओर को पुनरावर्ती के मार्ग के साथ पुनरावर्ती रूप से बनाया गया है, जबकि दाईं ओर ( 0 + x1 + … ) बाकी के टेम्पलेट में उसी समय जमा हुआ है। उसी तकनीक का उपयोग उदाहरण printf टेम्पलेट में किया जाता है।

उदाहरण: प्रिंटफ

अब हम printf टेम्पलेट की परिभाषा की जांच करेंगे, जिसका उल्लेख लेख के पहले भाग में किया गया था। निम्नलिखित स्पष्टीकरण के साथ कोड है, साथ ही साथ इसका उपयोग करने वाला मुख्य मॉड्यूल भी है। आप इसे कमांड ghc -XTemplateHaskell --make Main.hs कर सकते हैं

• Main.hs
  

   {-# LANGUAGE TemplateHaskell #-} module Main where --    printf import Printf (printf) --  $( … )      --   Haskell-     --       –   putStrLn main = putStrLn ( $(printf "Error in file %s line %d: %s") "io.cpp" 325 "printer not found" ) 

  
  
  Printf.hs
  

   {-# LANGUAGE TemplateHaskell #-} module Printf where --   Template Haskell import Language.Haskell.TH --    data Format = D --  "%d" –   | S --  "%s" –   | L String --    (L  Literally) --    –     Format parse :: String -> String -> [Format] parse "" rest = [L rest] parse ('%':'d':xs) rest = L rest : D : parse xs "" parse ('%':'s':xs) rest = L rest : S : parse xs "" parse (x:xs) rest = parse xs (rest++[x]) --  Haskell-,    --   - gen :: [Format] -> ExpQ -> ExpQ gen [] code = code gen (D : xs) code = [| \x -> $(gen xs [| $code ++ show x |]) |] gen (S : xs) code = [| \x -> $(gen xs [| $code ++ x |]) |] gen (L s : xs) code = gen xs [| $code ++ s |] -- ,       --       printf :: String -> ExpQ printf s = gen (parse s "") [| "" |] 

  
  
  यह अनुवादित टिप्पणियों वाला लेखक कोड है। एक समान, लेकिन कम (और सरल, मेरी राय में) समाधान यहां पाया जा सकता है: जिस्ट ।
  
  

  अन्य उदाहरण

  
  मैंने फ़ंक्शन घोषणाओं को उद्धृत करने और नामों को चिपकाने के साथ थोड़ा प्रयोग किया - ये प्रयोग मेरे ब्लॉग में वर्णित हैं। मुझे सलाह और सिफारिशों पर खुशी होगी।