गैर-कंपोजिट: डॉकिंग योजनाओं की रचना करने की कोशिश करना

परिचय

हास्केल में, यह फंक्शनलर्स के रूप में प्रभाव के साथ काम करने के लिए प्रथागत है, जिनकी वस्तुएं कुछ अभिव्यक्तियां हैं जिन्हें हम इस समय रुचि रखते हैं।

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

जारी रखने से पहले, लेख कई परिभाषाओं का उपयोग करेगा:

type (:=) ta = ta -- |   type (:.) tua = t (ua) -- |   type (~>) tu = forall a . ta -> ua -- |   

उदाहरण के लिए: सूची:। हो सकता है: = a - यह अभिव्यक्ति कल्पना करना आसान है, यह उन मूल्यों की एक सूची है जिनके अस्तित्व का सवाल है।

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

रचनाएँ और ट्रांसफ़ॉर्मर

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

रचनाओं:

• उन्हें बनाने के लिए किसी अतिरिक्त प्रकार की आवश्यकता नहीं है
• फ़नकार / आवेदक / मोनाड वर्गों के साथ विलय प्रभाव के लिए कोई सामान्य विधि नहीं है
• सब कुछ आश्चर्यजनक रूप से रचना करता है जब तक कि यह मोनाड्स में नहीं आता है

ट्रांसफॉर्मर:

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

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

डॉकिंग स्कीम

यदि हम monad ट्रांसफार्मर के प्रकारों पर करीब से नज़र डालें, तो हम कुछ पैटर्न की पहचान कर सकते हैं:

 newtype ReaderT rma = ReaderT { runReaderT :: r -> ma } newtype MaybeT ma = MaybeT { runMaybeT :: m (Maybe a) } newtype ExceptT ema = ExceptT { runExceptT :: m (Either ea)) } newtype StateT sma = StateT { runStateT :: s -> m (a,s) } 

ट्रांसफॉर्मर एक विशेष मामले का वर्णन करते हैं कि कैसे वर्तमान निश्चित और अनिश्चित प्रभाव को जाल करना चाहिए।

चलो निश्चित हो और यू अनिश्चितकालीन हो, कोशिश करो:

 Reader: r -> ua ===> (->) r :. u := a ===> t :. u := a -- t ~ (->) r Maybe: u (Maybe a) ===> u :. Maybe := a ===> u :. t := a -- t ~ Maybe Either: u (Either ea) ===> u :. Either e := a ===> u :. t := a -- t ~ Either e 

कुछ प्रभाव काफी जटिल होते हैं और इन्हें अन्य की रचना के माध्यम से परिभाषित किया जा सकता है, सरल प्रभाव:

 State: s -> u (a, s) ===> (->) s :. (,) s := a ==> t :. u :. t' := a -- t ~ (->) s, t' ~ (,) s newtype State sa = State ((->) s :. (,) s := a) 

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

आइए इन पैटर्नों को प्रकारों में व्यक्त करने का प्रयास करें:

 newtype TU tua = TU (t :. u := a) newtype UT tua = UT (u :. t := a) newtype TUT tut' a = TUT (t :. u :. t' := a) 

हमने केवल डॉकिंग योजनाओं को परिभाषित किया है - यह एक आवरण में फंक्शनलर्स की एक रचना है जो एक विशिष्ट और अनिश्चित प्रभाव की स्थिति को इंगित करता है।

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

 class Composition t where type Primary ta :: * run :: ta -> Primary ta 

अब हमारे पास इन सर्किटों को चलाने का एक सार्वभौमिक तरीका है:

 instance Composition (TU tu) where type Primary (TU tu) a = t :. u := a run (TU x) = x instance Composition (UT tu) where type Primary (UT tu) a = u :. t := a run (UT x) = x instance Composition (TUT tu t') where type Primary (TUT tu t') a = t :. u :. t' := a run (TUT x) = x 

ट्रांसफार्मर के बारे में क्या? यहां, आपको एक प्रकार के वर्ग की भी आवश्यकता होगी जिसमें एक डॉकिंग योजना एक विशेष प्रकार के लिए निर्धारित की जाती है, ट्रांसफार्मर के स्तर के लिए अनिश्चित प्रभाव को बढ़ाने के लिए और ट्रांसफार्मर में एक विशिष्ट प्रभाव का निर्माण करने के लिए अंतर्निहित विधि की घोषणा की जाती है:

 class Composition t => Transformer t where type Schema (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> tu embed :: Functor u => u ~> Schema tu build :: Applicative u => t ~> Schema tu type (:>) tua = Transformer t => Schema tua 

अब यह उदाहरणों की घोषणा करने के लिए बना हुआ है, शायद और कहीं से शुरू करें:

 instance Transformer Maybe where type Schema Maybe u = UT Maybe u embed x = UT $ Just <$> x build x = UT . pure $ x instance Transformer (Either e) where type Schema (Either e) u = UT (Either e) u embed x = UT $ Right <$> x build x = UT . pure $ x 

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

 newtype Reader ea = Reader (e -> a) instance Composition (Reader e) where type Primary (Reader e) a = (->) ea run (Reader x) = x instance Transformer (Reader e) where type Schema (Reader e) u = TU ((->) e) u embed x = TU . const $ x build x = TU $ pure <$> run x 

राज्य के साथ कुछ ऐसा ही करें:

 newtype State sa = State ((->) s :. (,) s := a) instance Composition (State s) where type Primary (State s) a = (->) s :. (,) s := a run (State x) = x instance Transformer (State s) where type Schema (State s) u = TUT ((->) s) u ((,) s) embed x = TUT $ \s -> (s,) <$> x build x = TUT $ pure <$> run x 

एक उदाहरण के रूप में

यह वास्तविक दुनिया की समस्याओं पर इसका परीक्षण करने के लिए बनी हुई है - एक उदाहरण के रूप में, हम एक कार्यक्रम लिखेंगे जो विभिन्न प्रकार के ब्रैकेट के सही प्लेसमेंट की गणना करता है।

कोष्ठकों के लिए परिभाषित प्रकार: वे खोलने और बंद हो सकते हैं; और भी अलग शैली है:

 data Shape = Opened | Closed data Style = Round | Square | Angle | Curly 

हमारे कार्यक्रम के अन्य प्रतीक दिलचस्प नहीं हैं:

 data Symbol = Nevermind | Bracket Style Shape 

हम उन त्रुटियों की एक सूची भी परिभाषित करते हैं जो हमारे कार्यक्रम का सामना कर सकती हैं:

 data Stumble = Deadend (Int, Style) --     | Logjam (Int, Style) --     | Mismatch (Int, Style) (Int, Style) --       

हमारे कार्यक्रम को किन प्रभावों की आवश्यकता है? हमें सत्यापन की प्रतीक्षा में कोष्ठक की एक सूची रखने की आवश्यकता है और हमें सामने आई पहली त्रुटि को रोकने की आवश्यकता है। हम एक ट्रांसफार्मर बनाते हैं:

 State [(Int, Style)] :> Either Stumble := () 

एल्गोरिथ्म सरल है: हम अनुक्रमित कोष्ठक के साथ संरचना से गुजरते हैं, यदि पारित होने के बाद हमें कोई त्रुटि नहीं हुई और हमारे पास अभी भी राज्य में ब्रैकेट हैं, तो खुले ब्रैकेट में एक बंद नहीं है:

 checking :: Traversable t => t (Int, Symbol) -> Either Stumble () checking struct = run (traverse proceed struct) [] >>= \case (s : _, _) -> Left . Logjam $ s where ([], _) -> Right () 

हम किसी भी खुले ब्रैकेट को याद करते हैं, पिछले याद किए गए ओपन के साथ किसी भी बंद की तुलना करें:

 proceed :: (Int, Symbol) -> State [(Int, Style)] :> Either Stumble := () proceed (_, Nevermind) = pure () proceed (n, Bracket style Opened) = build . modify . (:) $ (n, style) procceed (n, Bracket closed Closed) = build get >>= \case []-> embed $ Left . Deadend $ (n, closed) ((m, opened) : ss) -> if closed /= opened then embed . Left $ Mismatch (m, opened) (n, closed) else build $ put ss where 

निष्कर्ष

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

Github पर लाइब्रेरी कोड | हैकेज डॉक्यूमेंटेशन | कोष्ठक उदाहरण