टेम्पलेट हास्केल का परिचय। भाग 3. टीएच के अन्य पहलू

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

• भाग 1. आवश्यक न्यूनतम
• भाग 2. कोड उपकरण का हवाला देते हुए

भौतिकीकरण

सामग्रीकरण (पुनरीक्षण) एक टेम्पलेट हास्केल उपकरण है जो प्रोग्रामर को संकलक प्रतीक तालिका से जानकारी प्राप्त करने की अनुमति देता है। ∷ Name → Q Info फ़ंक्शन ∷ Name → Q Info करता है ∷ Name → Q Info किसी दिए गए नाम के बारे में ∷ Name → Q Info देता है: यदि यह एक वैश्विक पहचानकर्ता (फ़ंक्शन, स्थिर, निर्माता) है - तो आपको इसका प्रकार मिलेगा, यदि यह एक प्रकार या वर्ग है - तो आपको इसकी संरचना मिल जाएगी। प्रकार की Info की परिभाषा Language.Haskell.TH.Syntax मॉड्यूल में पाई जा सकती है।
भौतिककरण का उपयोग एक प्रकार की संरचना प्राप्त करने के लिए किया जा सकता है, लेकिन इस तरह से एक फ़ंक्शन बॉडी प्राप्त करना असंभव है। यदि आपको किसी फ़ंक्शन के शरीर को भौतिक बनाने की आवश्यकता है, तो आपको फ़ंक्शन की परिभाषा को उद्धृत करने की आवश्यकता है और आप किसी अन्य टेम्पलेट का उपयोग करके इस परिभाषा के साथ काम करना जारी रख सकते हैं। उदाहरण के लिए, इस तरह:

 $(optimize [d| fib = … |]) 

या तो

 fib = $(optimize [| … |]) 

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

लाइट के नाम उद्धृत

ब्याज की पहचानकर्ता के नाम () ∷ Name ) को प्राप्त करने के लिए, आप mkName फ़ंक्शन का उपयोग कर सकते हैं, लेकिन यह एक सुरक्षित समाधान नहीं है, क्योंकि mkName एक mkName नाम देता है, जिसे संदर्भ के आधार पर अलग-अलग व्याख्या की जा सकती है। और यहाँ कोड VarE id ← [| foo |] VarE id ← [| foo |] इस अर्थ में सुरक्षित है, जैसा कि नामों को उद्धृत करने के योग्य है ( My.Own.Module.foo कुछ My.Own.Module.foo ), लेकिन यह कोड बहुत अधिक My.Own.Module.foo और इसका उपयोग करने के लिए एक अद्वैत संदर्भ की आवश्यकता है। सौभाग्य से, टेम्प्लेट हास्केल के पास नामों को उद्धृत करने का एक और सरल रूप है: 'foo ( 'foo से पहले एकल उद्धरण) टाइप Name और इसमें एक योग्य नाम है जो पहचानकर्ता foo मेल खाता है, इसलिए कोड let id = 'foo कोड के अर्थ में बराबर है VarE id ← [| foo |] VarE id ← [| foo |] । ध्यान दें कि इस निर्माण में एक सरल Name प्रकार है ( Q Exp या Q Name ), इसलिए इसका उपयोग किया जा सकता है जहां उदाहरण के लिए संभव नहीं है, उदाहरण के लिए:

 f ∷ Exp → Exp f (App (Var m) e) | m == 'map = … 

यह नया रूप फिर भी एक उद्धरण है और कोष्ठक के उद्धरण के समान नियमों का पालन करता है [| … |] [| … |] उदाहरण के लिए, इसका उपयोग इन ब्रैकेट के अंदर नहीं किया जा सकता (यह संभव नहीं है: [| 'foo |] ), लेकिन इसे ग्लूइंग लागू नहीं किया जा सकता है (यह भी असंभव है: $( 'foo ) ), क्योंकि टाइप करने के लिए Q … आवश्यकता होती है। Q … । इससे भी महत्वपूर्ण बात, इस रूप को परिभाषित किया गया है, एक स्पष्ट व्याख्या के साथ पूरी तरह से योग्य नाम लौटाते हुए।
हास्केल के नामस्थान चीजों को थोड़ा जटिल करते हैं। भाव [| P |] [| P |] अर्थ है [| P |] का डेटा निर्माता, जबकि [t| P |] [t| P |] अर्थ है [t| P |] का प्रकार P इसलिए, "सुविधाजनक उद्धरण" के लिए, इन संस्थाओं को अलग करने का एक ही तरीका आवश्यक है। एक प्रकार के संदर्भ के लिए, केवल दो एकल उद्धरणों का उपयोग किया जाता है:

• 'Foo अर्थ है "एक अभिव्यक्ति के संदर्भ में Foo डेटा निर्माता"
• 'foo अर्थ है "अभिव्यक्ति के संदर्भ में नाम foo "
• ''Foo अर्थ है "प्रकार के संदर्भ में Foo का निर्माण"
• ''foo अर्थ है "प्रकार के संदर्भ में एक प्रकार का foo "

Show क्लास के अवतारों के निर्माण के उदाहरण में एक हल्के प्रशस्ति पत्र का उपयोग किया जाता है, जिसे अंत में पार्स किया जाता है।

त्रुटि संदेश और पुनर्प्राप्ति

प्रशस्ति पत्र मोनाड आपको त्रुटि संदेश भेजने और पुनर्प्राप्त करने की अनुमति देता है।

 report ∷ Bool → String → Q () 

report फ़ंक्शन दूसरे तर्क में दिए गए संदेश को प्रदर्शित करता है। यदि पहला तर्क True , तो परिणाम को त्रुटि के रूप में माना जाता है, अन्यथा, संदेश बस प्रदर्शित किया जाता है ( चेतावनी के रूप में )। किसी भी मामले में, गणना जारी रहती है, अगर उन्हें रोकने की आवश्यकता होती है, तो मोनड fail उपयोग करें। यदि कोई "क्लोज़िंग" recover , तो संकलन विफल हो जाता है।

 recover ∷ Q a → Q a → Q a 

recover ab को recover ab करने के recover ab एक कॉल शुरू होता है b । अगर b की report True "…" है, तो a । यदि b ऐसी त्रुटियों के बिना समाप्त होता है, तो इसका परिणाम वापस आ जाता है, और a अनदेखा कर दिया a है।

 location ∷ Q Loc 

यह कोड में स्थान के निर्देशांक (स्थानीय संरचना के रूप में) को लौटाता है जहां वर्तमान ग्लूइंग हो रहा है - यह त्रुटि संदेशों के लिए सुविधाजनक हो सकता है।

डिबगिंग

टीएच कार्यक्रमों की डिबगिंग को सरल बनाने के लिए, जीएचसी एक विशेष ध्वज -ddump-splices का समर्थन करता है, जिसके साथ यह मॉड्यूल लोडिंग के दौरान सभी शीर्ष-स्तरीय टेम्पलेट्स को चिपकाने के परिणाम दिखाता है।
इसके अलावा, दुभाषिया में, आप फ़ंक्शन runQ ∷ Q a → IO a का उपयोग करके ∷ Q a → IO a में गणना शुरू कर सकते हैं और परिणाम को या तो सार सिंटैक्स (AST) के रूप में या संबंधित Hellell कोड के रूप में प्रदर्शित कर सकते हैं:

 $ ghci –XTemplateHaskell … Prelude> :m + Language.Haskell.TH Prelude Language.Haskell.TH> runQ [| \x _ -> x |] >>= print LamE [VarP x_1,WildP] (VarE x_1) Prelude Language.Haskell.TH> runQ [| \x _ -> x |] >>= putStrLn . pprint \x_0 _ -> x_0 

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

 module Cnst where import Language.Haskell.TH cnst :: Int -> String -> Q Exp cnst ns = return (LamE (replicate n WildP) (LitE (StringL s))) 

अब यह दुभाषिया में परीक्षण किया जा सकता है:

 $ ghci -XTemplateHaskell Cnst.hs … *Cnst> runQ (cnst 2 "str") >>= print LamE [WildP,WildP] (LitE (StringL "str")) *Cnst> runQ (cnst 2 "str") >>= putStrLn . pprint \_ _ -> "str" 

एक ही बात मॉड्यूल में किया जा सकता है कि आयात टेम्पलेट्स:

 {-# LANGUAGE TemplateHaskell #-} module Main where import Language.Haskell.TH import Cnst --  cnst    : cnst1 :: t -> [Char] cnst1 = $(cnst 1 "x") cnst2 :: t1 -> t2 -> [Char] cnst2 = $(cnst 2 "str") -- ,    20  cnst20 = $(cnst 20 "foo") --     ,   runQ: main = do runQ(cnst 1 "x") >>= print runQ(cnst 2 "str") >>= print runQ(cnst 20 "foo") >>= print runQ(cnst 1 "x") >>= putStrLn.pprint runQ(cnst 2 "str") >>= putStrLn.pprint runQ(cnst 20 "foo") >>= putStrLn.pprint 

उदाहरण: deriveShow

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

• Main.hs

  {-# LANGUAGE TemplateHaskell #-} module Main where import Derive data T = A Int String | B Integer | C $(deriveShow ''T) main = print [A 1 "s", B 2, C] --    [A 1 "s",B 2,C] 

• Derive.hs

  {-# LANGUAGE TemplateHaskell #-} module Derive where import Language.Haskell.TH import Control.Monad data T1 = T1 --  ,   -- n       genPE :: Int -> Q ([PatQ], [ExpQ]) genPE n = do ids <- replicateM n (newName "x") return (map varP ids, map varE ids) --     show   : -- show (A x1 x2) = "A "++show x1++" "++show x2 showClause :: Con -> Q Clause showClause (NormalC name fields) = do --  , .. "A". nameBase     let constructorName = nameBase name --          (pats,vars) <- genPE (length fields) --    (" "++show x1++...++"")    [x1, ...] let f [] = [| constructorName |] f (v:vars) = [| " " ++ show $v ++ $(f vars) |] --     clause [conP name pats] -- (A x1 x2) (normalB (f vars)) [] -- "A"++" "++show x1++" "++show x2 --  ,      Show deriveShow :: Name -> Q [Dec] deriveShow t = do --       t TyConI (DataD _ _ _ constructors _) <- reify t --        show: -- show (A x1 x2) = "A "++show x1++" "++show x2 -- show (B x1) = "B "++show x1 -- show C = "C" showbody <- mapM showClause constructors --          --   (T1)    (x = "text")   showbody d <- [d| instance Show T1 where show x = "text" |] let [InstanceD [] (AppT showt (ConT _T1)) [FunD showf _text]] = d return [InstanceD [] (AppT showt (ConT t )) [FunD showf showbody]] 

निष्कर्ष

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