गैर-कंपोज करने की कोशिश करना: सब कुछ जुटाना

यह अनुशंसा की जाती है कि यदि आपने पहले से ऐसा नहीं किया है तो आप पहला लेख पढ़ें। यह लेख छोटा होगा, विवरणों पर कम और क्षमताओं पर अधिक ध्यान केंद्रित किया जाएगा।

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

भविष्य बहुत दूर नहीं है, इसलिए आपको अभी शुरुआत करने की आवश्यकता है।

अन्य प्रभावों के लिए प्रभाव बढ़ाना

class Liftable eff schema where lift :: eff ~> schema 

सार में "उत्थान" का क्या अर्थ है? लिफ्ट एक ही शुद्ध / रिटर्न है, इस अपवाद के साथ कि हम प्रभाव में मूल्य को विसर्जित नहीं करते हैं, लेकिन किसी प्रकार के ट्रांसफार्मर में प्रभाव (हमारे मामले में, ट्रांसफार्मर सर्किट में):

 pure :: a -> ta lift :: ua -> tua 

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

इस प्रकार, हम सुरक्षित रूप से उठाए गए प्रभावों की रचना कर सकते हैं:

 let f = lift get :: Configured _ t => t _ let g = lift Nothing :: Optional t => t _ let h = lift (failure _) :: Failable _ t => t _ let x = f *> g *> h :: (Applicative t, Configured _ t, Optional t, Failable _ t) => t _ 

और उन्हें हमारे लिए सुविधाजनक किसी भी क्रम में प्रस्तुत करें:

 let y = pure _ :: Reader _ :> State _ :> Either _ :> Maybe := Int let z = pure _ :: State _ :> Either _ :> Maybe _ :> Reader := _ let x = f *> g *> h :: (Applicative t, Configured _ t, Optional t, Failable _ t) => t _ let xy = x *> y :: Reader _ :> State _ :> Either _ :> Maybe := _ let xz = x *> z :: State _ :> Either _ :> Maybe _ :> Reader := _ 

दूसरों पर कुछ प्रभाव डालते हैं

 class Adaptable subeff eff | subeff -> eff where adapt :: subeff ~> eff 

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

 lift put :: Accumulated _ t => t _ lift get :: Configured _ t => t _ (lift . adapt $ put) :: Stateful _ t => t _ (lift . adapt $ get) :: Stateful _ t => t _ 

यह कैसे संभव है? पिछले लेख में, हमने राज्य को दो प्रभावों में विभाजित किया है:

 State s = (->) s :. (,) s 

रीडर के मामले में, हम राज्य स्तर पर एरो फंक्टर को बढ़ाते हैं, और राइटर के मामले में टपर फनकार:

 Reader s = (->) s Writer s = (,) s 

हम वैकल्पिक के लिए उपलब्ध नहीं कर सकते हैं, लेकिन हम त्रुटि जानकारी खो देंगे:

 (lift $ Just _) :: Optional t => t _ (lift $ failure _) :: Failable _ t => t _ (lift . adapt $ failure _) :: Optional t => t _ 

ट्रांसफार्मर में प्रभाव चलाएँ

एक ट्रांसफार्मर में एक प्रभाव की व्याख्या करने के लिए, एक रन विधि पर्याप्त है:

 let xy = x *> y :: Reader _ :> State _ :> Either _ :> Maybe := _ let xy' = run xy _ :: State _ :> Either _ :> Maybe := _ let xy'' = run xy' _ :: Either _ :> Maybe := _ let xy''' = run xy'' :: Maybe (Either _) _ 

निष्कर्ष और उदाहरण

तो, अभी, बिना मुफ्त / मुफ्त मठों (और कभी-कभी बिना साधुओं के भी) के साथ, संयुक्त का उपयोग करके आप अपने भावों को उनके प्रभाव के अनुसार टाइप कर सकते हैं। आप सभी की जरूरत है फंक्शंस की एक रचना है।

रोस्तोव-ऑन-डॉन की एक स्थानीय रैली में इस विषय पर एक रिपोर्ट की एक प्रस्तुति भी है, जिसे एक ब्राउज़र में देखा जा सकता है।

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