हाय, हैब्र।

पिछली बार, हमने वर्णन किया Has पैटर्न है, उन समस्याओं को रेखांकित करता है जो इसे हल करती हैं, और कुछ विशिष्ट उदाहरण लिखे:

 instance HasDbConfig AppConfig where getDbConfig = dbConfig instance HasWebServerConfig AppConfig where getWebServerConfig = webServerConfig instance HasCronConfig AppConfig where getCronConfig = cronConfig 

यह अच्छा लग रहा है। यहां क्या मुश्किलें पैदा हो सकती हैं?

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

 instance HasDbConfig DbConfig where getDbConfig = id 

वे हमें आसानी से व्यक्तिगत परीक्षण या सहायक उपयोगिताओं को लिखने की अनुमति देते हैं जो पूरे AppConfig स्वतंत्र हैं।

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

 instance HasDbConfig (DbConfig, b) where getDbConfig = fst instance HasDbConfig (a, DbConfig) where getDbConfig = snd 

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

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

Has क्लास को सारांशित करना

पहले, ध्यान दें कि हमारे पास अलग-अलग वातावरण के लिए अलग-अलग कक्षाएं हैं। यह एक सार्वभौमिक समाधान बनाने में हस्तक्षेप कर सकता है, इसलिए हमने पर्यावरण को एक अलग पैरामीटर में रखा है:

 class Has part record where extract :: record -> part 

हम कह सकते हैं कि Has part record मतलब है कि टाइप record के मूल्य से कुछ प्रकार के part निकाले जा सकते हैं। इन शब्दों में, हमारे अच्छे पुराने HasDbConfig Has DbConfig हो Has DbConfig , और इसी तरह अन्य टाइपकास्ट के लिए जो हमने पहले लिखा था। यह लगभग विशुद्ध रूप से वाक्य-विन्यास में बदल जाता है, और, उदाहरण के लिए, हमारी पिछली पोस्ट के कार्यों में से एक का प्रकार बदल जाता है

 doSmthWithDbAndCron :: (MonadReader rm, HasDbConfig r, HasCronConfig r) => ... 

में

 doSmthWithDbAndCron :: (MonadReader rm, Has DbConfig r, Has CronConfig r) => ... 

एकमात्र परिवर्तन सही स्थानों में कुछ स्थान है।

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

अब जब हम विशिष्ट प्रकार के पर्यावरण की परवाह नहीं करते हैं, तो आइए देखें कि कौन से रिकॉर्ड निश्चित part लिए Has part record क्लास को लागू कर सकते हैं। इस कार्य की एक अच्छी प्रेरक संरचना है:

1. प्रत्येक प्रकार में स्वयं होता है: Has record record को तुच्छ तरीके से लागू किया जाता है ( extract = id )।
2. यदि record प्रकार rec1 और rec2 का एक उत्पाद है, तो Has part record कार्यान्वित किया जाता है यदि और केवल या तो Has part rec1 या Has part rec2 ।
3. यदि record प्रकार rec1 और rec2 का योग है, तो Has part record कार्यान्वित किया जाता है यदि और केवल Has part rec1 और Has part rec2 । यद्यपि इस संदर्भ में इस मामले की व्यावहारिक व्यापकता स्पष्ट नहीं है, फिर भी यह पूर्णता के लिए ध्यान देने योग्य है।

इसलिए, ऐसा लगता है कि हमने एक एल्गोरिथ्म का एक स्केच तैयार किया है ताकि यह निर्धारित किया जा सके कि Has part record part और record डेटा के लिए लागू है!

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

मैं जेनेरिक पर एक और ट्यूटोरियल नहीं लिखूंगा, इसलिए बस कोड पर जाएं।

पहला प्रयास

हम सहायक श्रेणी के GHas माध्यम से अपनी Generic कार्यान्वयन की क्लासिक पद्धति का उपयोग करेंगे:

 class GHas part grecord where gextract :: grecord p -> part 

यहाँ grecord हमारे record प्रकार का एक Generic प्रतिनिधित्व है।

GHas कार्यान्वयन उन प्रेरक संरचना का अनुसरण करते हैं जिन्हें हमने ऊपर उल्लेख किया है:

 instance GHas record (K1 i record) where gextract (K1 x) = x instance GHas part record => GHas part (M1 it record) where gextract (M1 x) = gextract x instance GHas part l => GHas part (l :*: r) where gextract (l :*: _) = gextract l instance GHas part r => GHas part (l :*: r) where gextract (_ :*: r) = gextract r 

1. K1 बेस केस से मेल खाता है।
2. M1 - जेनरिक-विशिष्ट मेटाडेटा जिसे हमें अपने कार्य में आवश्यकता नहीं है, इसलिए हम बस उन्हें अनदेखा करते हैं और उनके माध्यम से जाते हैं।
3. उत्पाद प्रकार l :*: r लिए पहला उदाहरण उस स्थिति से मेल खाता है जब उत्पाद के "बाएं" भाग में उस प्रकार के part का मूल्य होता है जिसकी हमें आवश्यकता होती है (संभवतः, पुनरावर्ती)।
4. इसी प्रकार, उत्पाद प्रकार l :*: r लिए दूसरा उदाहरण उस स्थिति से मेल खाता है जब उत्पाद के "दाएं" भाग में टाइप part (स्वाभाविक रूप से, संभवतः, पुनरावर्ती) का वांछित मान होता है।

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

इसके अलावा, यह ध्यान रखना उपयोगी है कि प्रत्येक $$$एन$-ary प्रकार-उत्पाद (a1, ..., an) को एक रचना के रूप में दर्शाया जा सकता है $$$n-1$जोड़े (a1, (a2, (a3, (..., an)))) , इसलिए मैं खुद को जोड़े के साथ उत्पाद प्रकारों को जोड़ने की अनुमति देता हूं।

हमारे GHas साथ, आप जेनरिक का उपयोग करने वाले Has लिए एक डिफ़ॉल्ट कार्यान्वयन लिख सकते हैं:

 class Has part record where extract :: record -> part default extract :: Generic record => record -> part extract = gextract . from 

हो गया।

या नहीं?

समस्या

यदि हम इस कोड को संकलित करने का प्रयास करते हैं, तो हम देखेंगे कि यह डिफ़ॉल्ट रूप से इस कार्यान्वयन का उपयोग करने के प्रयास के बिना भी taypechaetsya नहीं करता है, वहां कुछ अतिव्यापी उदाहरणों की रिपोर्टिंग करता है। इससे भी बदतर, ये उदाहरण कुछ मायनों में समान हैं। ऐसा लगता है कि यह पता लगाने का समय है कि हास्केल में उदाहरणों को हल करने के लिए तंत्र कैसे काम करता है।

हमारे पास हो सकता है

 instance context => Foo barPattern bazPattern where ... 

(वैसे, इस चीज के बाद => को उदाहरण प्रधान कहा जाता है।)

ऐसा पढ़ना स्वाभाविक लगता है

आइए हमें Foo bar baz लिए एक उदाहरण चुनने की आवश्यकता है। यदि context संतुष्ट है, तो आप इस उदाहरण का चयन कर सकते हैं बशर्ते कि bar और barPattern और bazPattern अनुरूप bazPattern ।

हालाँकि, यह एक गलत व्याख्या है, और इसके ठीक विपरीत है:

आइए हमें Foo bar baz लिए एक उदाहरण चुनने की आवश्यकता है। यदि bar और bazPattern , barPattern और bazPattern अनुरूप हैं, तो हम इस उदाहरण का चयन करते हैं और स्थिरांक की सूची में context जोड़ते हैं जिन्हें हल किया जाना चाहिए।

अब यह स्पष्ट है कि समस्या क्या है आइए निम्नलिखित उदाहरणों पर एक नज़र डालें:

 instance GHas part l => GHas part (l :*: r) where gextract (l :*: _) = gextract l instance GHas part r => GHas part (l :*: r) where gextract (_ :*: r) = gextract r 

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

इसके अलावा, इन उदाहरणों को किसी तरह से परिष्कृत करने का कोई तरीका नहीं है ताकि वे ओवरलैप करने के लिए संघर्ष न करें। खैर, इसके अलावा और GHas मापदंडों को जोड़ना।

अभिव्यक्त प्रकार बचाव के लिए भागते हैं!

समस्या का हल "पथ" की गणना हमारे लिए ब्याज के मूल्य से पहले करना है, और उदाहरणों की पसंद को निर्देशित करने के लिए इस रास्ते का उपयोग करना है।

चूंकि हम योग प्रकारों का समर्थन नहीं करने के लिए सहमत थे, इसलिए एक पथ शाब्दिक अर्थ में उत्पाद प्रकारों में बाएँ या दाएँ घुमाव का एक क्रम है (जो कि एक जोड़ी के पहले या दूसरे घटक की पसंद है), एक बड़े "HERE" पॉइंटर के साथ समाप्त होता है, जैसे ही हमें वांछित प्रकार मिलते हैं। । हम इसे लिखते हैं:

 data Path = L Path | R Path | Here deriving (Show) 

 data DbConfig = DbConfig { dbAddress :: DbAddress , dbUsername :: Username , dbPassword :: Password } data AppConfig = AppConfig { dbConfig :: DbConfig , webServerConfig :: WebServerConfig , cronConfig :: CronConfig } 

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

वास्तव में, हमारे मानक वेब सेवा उदाहरण पर विचार करें। यदि कोई व्यक्ति प्रकार (Host, Port) का मान प्राप्त करना चाहता है, तो क्या यह डेटाबेस सर्वर का पता या वेब सर्वर का पता होना चाहिए? इसे जोखिम में नहीं डालना बेहतर है।

किसी भी स्थिति में, आइए इसे कोड में व्यक्त करें:

 data MaybePath = NotFound | Conflict | Found Path deriving (Show) 

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

अब हम उत्पाद प्रकारों के एक विशेष मामले पर विचार करते हैं (जो, जैसा कि हम सहमत थे, हम जोड़े के रूप में मानते हैं)। उनमें वांछित प्रकार का मूल्य कैसे ढूंढें? आप एक जोड़ी के प्रत्येक घटक में पुनरावर्ती रूप से खोज कर सकते हैं p2 क्रमशः p1 और p2 परिणाम प्राप्त कर सकते हैं, और फिर किसी तरह उन्हें जोड़ सकते हैं।

चूंकि हम संकलन के दौरान होने वाले टाइमक्लस के उदाहरणों के विकल्प के बारे में बात कर रहे हैं, हमें वास्तव में संकलन की गणना की आवश्यकता है, जो कि हास्केल में प्रकारों पर संगणना के माध्यम से व्यक्त किए जाते हैं (भले ही DataKinds का उपयोग करके ब्रह्मांड में उठाए गए शब्दों के माध्यम से प्रतिनिधित्व किया जाता है)। तदनुसार, प्रकारों पर इस तरह के एक कार्य को प्रकार परिवार के रूप में दर्शाया जाता है:

 type family Combine p1 p2 where Combine ('Found path) 'NotFound = 'Found ('L path) Combine 'NotFound ('Found path) = 'Found ('R path) Combine 'NotFound 'NotFound = 'NotFound Combine _ _ = 'Conflict 

यह फ़ंक्शन कई मामलों का प्रतिनिधित्व करता है:

1. यदि पुनरावर्ती खोजों में से एक सफल है, और दूसरा NotFound है, तो हम सफल खोज से रास्ता NotFound हैं और सही दिशा में मोड़ को जोड़ते हैं।
2. यदि दोनों पुनरावर्ती खोज NotFound साथ समाप्त हो NotFound , तो जाहिर है पूरी खोज NotFound साथ समाप्त हो NotFound ।
3. किसी अन्य मामले में, हम Conflict ।

अब हम एक टिप-स्तरीय फ़ंक्शन लिखेंगे जो कि पाया जाने वाला part लेता है, और उस प्रकार का एक Generic प्रतिनिधित्व जिसमें part ढूंढना है, और खोज करता है:

 type family Search part (grecord :: k -> *) :: MaybePath where Search part (K1 _ part) = 'Found 'Here Search part (K1 _ other) = 'NotFound Search part (M1 _ _ x) = Search part x Search part (l :*: r) = Combine (Search part l) (Search part r) Search _ _ = 'NotFound 

ध्यान दें कि हमें GHas साथ हमारे पिछले प्रयास के अर्थ में कुछ समान था। यह उम्मीद की जानी है, क्योंकि हम वास्तव में एल्गोरिथ्म को पुन: पेश कर रहे हैं जिसे हमने टाइमक्लस के माध्यम से व्यक्त करने की कोशिश की थी।

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

 class GHas (path :: Path) part grecord where gextract :: Proxy path -> grecord p -> part 

हमने gextract लिए एक अतिरिक्त तर्क भी जोड़ा ताकि संकलक दिए गए पथ के लिए सही उदाहरण का चयन कर सके (जिसे इसके लिए फ़ंक्शन हस्ताक्षर में उल्लेख किया जाना चाहिए)।

अब उदाहरण लिखना बहुत आसान है:

 instance GHas 'Here record (K1 i record) where gextract _ (K1 x) = x instance GHas path part record => GHas path part (M1 it record) where gextract proxy (M1 x) = gextract proxy x instance GHas path part l => GHas ('L path) part (l :*: r) where gextract _ (l :*: _) = gextract (Proxy :: Proxy path) l instance GHas path part r => GHas ('R path) part (l :*: r) where gextract _ (_ :*: r) = gextract (Proxy :: Proxy path) r 

दरअसल, हम केवल उस पथ के आधार पर वांछित उदाहरण का चयन करते हैं जिस path गणना हमने पहले की थी।

अब extract :: record -> part हमारे default क्रियान्वयन को कैसे लिखें extract :: record -> part Has क्लास में extract :: record -> part फंक्शन? हमारी कई शर्तें हैं:

1. record Generic को लागू करना चाहिए ताकि जेनेरिक तंत्र लागू किया जा सके, इसलिए हमें Generic record मिलता है।
2. Search फ़ंक्शन को record (या बल्कि, record के Generic प्रतिनिधित्व में, जिसे Rep record रूप में व्यक्त किया गया है) part मिलना चाहिए। कोड में, यह थोड़ा और असामान्य लगता है: Search part (Rep record) ~ 'Found path । इस रिकॉर्ड का मतलब यह है कि Search part (Rep record) का परिणाम 'Found path कुछ path लिए 'Found path path (जो वास्तव में, हमारे लिए दिलचस्प है) के बराबर होना चाहिए।
3. हमें part के साथ-साथ अंतिम चरण से record और path के सामान्य प्रतिनिधित्व के साथ GHas का उपयोग करने में सक्षम होना चाहिए, जो कि GHas path part (Rep record) में बदल जाता है।

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

 type SuccessfulSearch part record path = (Search part (Rep record) ~ 'Found path, GHas path part (Rep record)) 

इस पर्यायवाची को देखते हुए, हम प्राप्त करते हैं

 class Has part record where extract :: record -> part default extract :: forall path. (Generic record, SuccessfulSearch part record path) => record -> part extract = gextract (Proxy :: Proxy path) . from 

अब सब कुछ!

जेनेरिक का उपयोग करना

इन सभी कार्यों को देखने के लिए, हम डमी के लिए कुछ सामान्य उदाहरण लिखेंगे:

 instance SuccessfulSearch a (a0, a1) path => Has a (a0, a1) instance SuccessfulSearch a (a0, a1, a2) path => Has a (a0, a1, a2) instance SuccessfulSearch a (a0, a1, a2, a3) path => Has a (a0, a1, a2, a3) 

यहाँ SuccessfulSearch a (a0, ..., an) path इस तथ्य के लिए जिम्मेदार है कि a0, ..., an बीच a0, ..., an बार होता है।

हो सकता है कि अब हमारे पास अच्छा पुराना हो

 data AppConfig = AppConfig { dbConfig :: DbConfig , webServerConfig :: WebServerConfig , cronConfig :: CronConfig } 

और हम Has DbConfig , Has WebServerConfig और Has CronConfig का उत्पादन करना चाहते हैं। यह DeriveGeneric और DeriveAnyClass को शामिल करने और सही deriving घोषणा को जोड़ने के लिए पर्याप्त है:

 data AppConfig = AppConfig { dbConfig :: DbConfig , webServerConfig :: WebServerConfig , cronConfig :: CronConfig } deriving (Generic, Has DbConfig, Has WebServerConfig, Has CronConfig) 

हम भाग्यशाली हैं (या हम पर्याप्त रूप से आनंदित थे) Has लिए तर्कों को व्यवस्थित करने के लिए ताकि नेस्टेड प्रकार का नाम पहले आए, ताकि हम DeriveAnyClass को कम करने के लिए DeriveAnyClass तंत्र पर भरोसा कर DeriveAnyClass ।

सुरक्षा पहले आती है

यदि हमारे पास कोई प्रकार नहीं है तो क्या होगा?

 data AppConfig = AppConfig { dbConfig :: DbConfig , webServerConfig :: WebServerConfig } deriving (Generic, Has CronConfig) 

नहीं, हमें टाइप परिभाषा के बिंदु पर एक त्रुटि मिलती है:

 Spec.hs:35:24: error: • Couldn't match type ''NotFound' with ''Found path0' arising from the 'deriving' clause of a data type declaration • When deriving the instance for (Has CronConfig AppConfig) | 35 | } deriving (Generic, Has CronConfig) | ^^^^^^^^^^^^^^ 

मित्रवत त्रुटि संदेश नहीं, लेकिन यहां तक ​​कि आप अभी भी यह समझ सकते हैं कि समस्या क्या है: विषम आवृत्ति NotFound विषम आवृत्ति CronConfig ।

क्या होगा यदि हमारे पास एक ही प्रकार के कई क्षेत्र हैं?

 data AppConfig = AppConfig { prodDbConfig :: DbConfig , qaDbConfig :: DbConfig , webServerConfig :: WebServerConfig , cronConfig :: CronConfig } deriving (Generic, Has DbConfig) 

जैसा कि अपेक्षित था: नहीं

 Spec.hs:37:24: error: • Couldn't match type ''Conflict' with ''Found path0' arising from the 'deriving' clause of a data type declaration • When deriving the instance for (Has DbConfig AppConfig) | 37 | } deriving (Generic, Has DbConfig) | ^^^^^^^^^^^^ 

सब कुछ वास्तव में अच्छा लगता है।

संक्षेप में देना

इसलिए, हम प्रस्तावित पद्धति को संक्षेप में तैयार करने का प्रयास करेंगे।

मान लीजिए कि हमारे पास कुछ प्रकार के टाइपक्लास हैं, और हम कुछ पुनरावर्ती नियमों के अनुसार इसके उदाहरणों को स्वचालित रूप से प्रदर्शित करना चाहते हैं। तब हम अस्पष्टताओं से बच सकते हैं (और आमतौर पर इन नियमों को व्यक्त करते हैं यदि वे nontrivial हैं और उदाहरणों को हल करने के लिए मानक तंत्र में फिट नहीं होते हैं) निम्नानुसार हैं:

1. हम एक प्रेरक डेटा प्रकार T के रूप में पुनरावर्ती नियमों को सांकेतिक शब्दों में बदलना T
2. हम इस प्रकार T (या, हास्केल के संदर्भ में, टाइप v प्रकार - जहां मेरे आश्रित प्रकार हैं) के प्रारंभिक गणना के लिए प्रकारों (प्रकार के परिवार के रूप में) पर एक फ़ंक्शन लिखेंगे, जिसमें उन चरणों के विशिष्ट अनुक्रम का वर्णन किया गया है जिन्हें लेने की आवश्यकता है।
3. Generic हेल्पर के एक अतिरिक्त तर्क के रूप में इस v उपयोग ऐसे उदाहरणों के विशिष्ट अनुक्रम को निर्धारित करने के लिए करें जो अब v के मूल्यों से मेल खाते हैं।

खैर, यह बात है!

निम्नलिखित पोस्ट में, हम इस दृष्टिकोण के कुछ सुरुचिपूर्ण एक्सटेंशन (साथ ही सुरुचिपूर्ण सीमाएं) को देखेंगे।

ओह, और हाँ। हमारे सामान्यीकरण के अनुक्रम को ट्रैक करना दिलचस्प है।

1. एन्व के साथ शुरू Env -> Foo ।
2. सामान्य रूप से पर्याप्त नहीं है, Reader Env मोनड में लपेटें।
3. सामान्य रूप से पर्याप्त नहीं है, MonadReader Env m साथ फिर से लिखना।
4. सामान्य रूप से पर्याप्त नहीं है, MonadReader rm, HasEnv r फिर से MonadReader rm, HasEnv r ।
5. सामान्य रूप से पर्याप्त नहीं है, MonadReader rm, Has Env r लिखें और जेनेरिक जोड़ें ताकि कंपाइलर वहां सब कुछ करे।
6. अब आदर्श है।