हास्केल पर 33 लाइनों में खरोंच से सहकारी धागे

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

टाइप

हास्केल एक ऐसी भाषा है जहां प्रकार प्राथमिक हैं, इसलिए हम धाराओं का प्रतिनिधित्व करने के लिए उपयुक्त प्रकार चुनकर शुरू करेंगे। सबसे पहले, हमें एक सरल भाषा में संकेत देना चाहिए जो धाराएँ हम बनाना चाहते हैं:

• धाराओं को मौजूदा अनुदेश अनुक्रम का विस्तार करना चाहिए
• थ्रेड्स को संचालन के एक सेट का समर्थन करना चाहिए: ब्रांचिंग, नियंत्रण हस्तांतरण और समाप्ति
• थ्रेड्स को विभिन्न प्रकार के शेड्यूलर्स की अनुमति देनी चाहिए

अब हम इन अवधारणाओं को हास्केल में अनुवादित करते हैं:

• जब आप "कई दुभाषियों / योजनाकारों / बैकेंड्स" को सुनते हैं, तो आपको "स्वतंत्र" (जैसा कि "मुक्त वस्तु") सोचना चाहिए
• जब आप "आदेशों का क्रम" सुनते हैं, तो आपको यह सोचना चाहिए: "भिक्षु।"
• जब आप किसी चीज़ का "विस्तार" करना चाहते हैं, तो आपको सोचना चाहिए: "ट्रांसफार्मर"।

इन शब्दों को एक साथ मिलाएं, और आपको सही गणितीय समाधान मिलेगा: "मुफ्त मोनाड ट्रांसफार्मर"।

सिंटेक्स का पेड़

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

हमने कहा कि हम चाहते हैं कि हमारी धारा या तो शाखा, या नियंत्रण को स्थानांतरित करे, या रोके, तो चलिए कांटे, रिटर्न और समाप्ति के साथ एक डेटा प्रकार करते हैं:

{-# LANGUAGE DeriveFunctor #-} data ThreadF next = Fork next next | Yield next | Done deriving (Functor) 

ThreadF हमारे अनुदेश सेट का परिचय देता है। हम तीन नए निर्देश जोड़ना चाहते थे, इसलिए थ्रेडएफ के पास तीन कंस्ट्रक्टर हैं, प्रत्येक कमांड के लिए एक: Fork , Yield और Done ।

हमारा ThreadF प्रकार वाक्यविन्यास के पेड़ में एक नोड का प्रतिनिधित्व करता है। निर्माणकर्ताओं के next क्षेत्र यह दर्शाते हैं कि नोड्स के बच्चों को कहाँ जाना चाहिए। Fork निष्पादन के दो तरीके बनाता है, इसलिए उसके दो बच्चे हैं। Done वर्तमान निष्पादन पथ पूरा करता है, इसलिए इसकी कोई संतान नहीं है। Yield न तो शाखाएं होती हैं और न ही वह समाप्त होती है, इसलिए उसका एक बच्चा है। व्युत्पन्न (फ़नकार) भाग बस मुफ्त मोनाड ट्रांसफार्मर को बताता है कि next क्षेत्र वे हैं जहाँ बच्चों को जाना चाहिए।

अब मुफ्त FreeT ट्रांसफार्मर FreeT हमारे कमांड के सिंटैक्स ट्री का निर्माण कर सकता है। हम इस पेड़ को एक धागा कहेंगे:

 --  `free`  import Control.Monad.Trans.Free type Thread = FreeT ThreadF 

एक अनुभवी हास्केल प्रोग्रामर इस कोड को पढ़ेगा, जैसे कि " Thread एक सिंटैक्स ट्री है जिसे ThreadF निर्देशों से बनाया गया है ThreadF "

अनुदेश

अब हमें आदिम निर्देशों की जरूरत है। free पैकेज liftF ऑपरेशन प्रदान करता है, जो एक कमांड को एक सिंटैक्स ट्री में एक नोड गहरे में परिवर्तित करता है:

 yield :: (Monad m) => Thread m () yield = liftF (Yield ()) done :: (Monad m) => Thread mr done = liftF Done cFork :: (Monad m) => Thread m Bool cFork = liftF (Fork False True) 

आपको पूरी तरह से यह समझने की आवश्यकता नहीं है कि यह कैसे काम करता है, यह देखने के अलावा कि प्रत्येक कमांड का लौटा मूल्य उस से मेल खाता है जो हम बच्चे के नोड भागों में संग्रहीत करते हैं:

• yield कमांड उसके बच्चे के रूप में बचाता है () , इसलिए फ़ंक्शन का रिटर्न मान है ()
• done आदेश में कोई संतान नहीं है, इसलिए संकलक का कहना है कि इसका एक बहुरूपिक वापसी मूल्य (यानी r ) है, जिसका अर्थ है कि यह कभी खत्म नहीं होगा
• cFork कमांड बच्चों के रूप में cFork संग्रहीत करता है, इसलिए यह एक Bool लौटाता है

cFork को इसका नाम इसलिए मिला क्योंकि यह C से एक fork फंक्शन की तरह व्यवहार करता है, जिसका अर्थ है कि लौटा हुआ बूलियन हमें बताता है कि हम ब्रांच करने के बाद किस ब्रांच पर हैं। यदि हम False , तो हम बाईं शाखा पर हैं और यदि हम True , तो हम सही शाखा पर हैं।

हम cFork को जोड़ सकते हैं और अधिक पारंपरिक हास्केल शैली में fork लागू करके फिर से कर सकते हैं, इस सम्मेलन का उपयोग करके कि बाईं शाखा "माता-पिता" है और दाईं शाखा "बच्चा" है:

 import Control.Monad fork :: (Monad m) => Thread ma -> Thread m () fork thread = do child <- cFork when child $ do thread done 

उपरोक्त कोड cFork कॉल cFork , और फिर यह कहता है, "अगर मैं एक बच्चा हूं, तो कांटे की कार्रवाई चलाएं और फिर बंद कर दें, अन्यथा हमेशा की तरह जारी रखें।"

नि: शुल्क भिक्षुओं

ध्यान दें कि कोड के अंतिम टुकड़े में कुछ असामान्य कैसे हुआ। हमने संकेतन का उपयोग करते हुए आदिम Thread थ्रेड निर्देशों से cFork और done कार्यों को संकलित done और हमें नया Thread वापस मिला। ऐसा इसलिए है क्योंकि हास्केल हमें किसी भी प्रकार के नोटेशन का उपयोग करने की अनुमति देता है जो कि मोनाड इंटरफ़ेस को लागू करता है और हमारा मुफ्त मोनाड ट्रांसफार्मर स्वचालित रूप से Thread लिए मोनाड instance वांछित instance निर्धारित करता है। स्वादिष्ट!

वास्तव में, हमारा मुफ्त मोनाड ट्रांसफार्मर बिल्कुल सुपर-स्मार्ट नहीं है। जब हम संकेतन का उपयोग करके एक मुफ्त मोनाड ट्रांसफार्मर को इकट्ठा do हैं, do जो कुछ भी किया जाता है वह इन आदिम सिंटैक्स पेड़ों को एक नोड गहरे (यानी निर्देशों) को एक बड़े सिंटैक्स ट्री में जोड़ने के लिए है। दो आदेशों का क्रम:

 do yield done 

... पहला कमांड (यानी yield ) के एक बच्चे के रूप में दूसरा कमांड (यानी done ) स्टोर करने के लिए बस desaccharized।

लूप प्रवाह प्रबंधक

अब हम अपने स्वयं के धागा अनुसूचक लिखने जा रहे हैं। यह एक भोला चक्रीय अनुसूचक होगा:

 --   O(1)      import Data.Sequence roundRobin :: (Monad m) => Thread ma -> m () roundRobin t = go (singleton t) --     where go ts = case (viewl ts) of --   : ! EmptyL -> return () --   :      t :< ts' -> do x <- runFreeT t --     case x of --       Free (Fork t1 t2) -> go (t1 <| (ts' |> t2)) --       Free (Yield t') -> go (ts' |> t') --  :     Free Done -> go ts' Pure _ -> go ts' 

... और हो गया! नहीं, वास्तव में, यह बात है! यह एक संपूर्ण स्ट्रीमिंग कार्यान्वयन है।

कस्टम धागे

चलो हमारे नए बहादुर स्ट्रीमिंग सिस्टम का प्रयास करें। चलो कुछ सरल से शुरू करते हैं।

 mainThread :: Thread IO () mainThread = do lift $ putStrLn "Forking thread #1" fork thread1 lift $ putStrLn "Forking thread #1" fork thread2 thread1 :: Thread IO () thread1 = forM_ [1..10] $ \i -> do lift $ print i yield thread2 :: Thread IO () thread2 = replicateM_ 3 $ do lift $ putStrLn "Hello" yield 

इनमें से प्रत्येक Thread IO () प्रकार Thread IO () । Thread एक "मोनड ट्रांसफार्मर" है, जिसका अर्थ है कि यह मौजूदा मोनाड को अतिरिक्त कार्यक्षमता के साथ विस्तारित करता है। हमारे मामले में, हम उपयोगकर्ता थ्रेड्स के साथ IO मोनाद का विस्तार करते हैं, और यह बदले में, इसका मतलब है कि हर बार हमें एक IO कार्रवाई को कॉल करने की आवश्यकता होती है, हम Thread में इस क्रिया को सम्मिलित करने के लिए lift का उपयोग करते हैं।

जब हम roundRobin फ़ंक्शन को कॉल करते हैं, तो हम अपने थ्रेड मोनाड ट्रांसफार्मर को बाहर निकालते हैं, और हमारे स्ट्रीम प्रोग्राम IO में निर्देशों के एक रैखिक अनुक्रम तक ढह जाते हैं।

 >>> roundRobin mainThread :: IO () Forking thread #1 Forking thread #1 1 Hello 2 Hello 3 Hello 4 5 6 7 8 9 10 

इसके अलावा, हमारे स्ट्रीमिंग सिस्टम साफ है! हम अन्य साधुओं का विस्तार कर सकते हैं, न कि केवल IO , और फिर भी स्ट्रीम प्रभाव प्राप्त कर सकते हैं! उदाहरण के लिए, हम Writer गणना की स्ट्रीमिंग बना सकते हैं, जहाँ Writer कई शुद्ध साधुओं में से एक है (इसके बारे में अधिक जानकारी के लिए, हब देखें):

 import Control.Monad.Trans.Writer logger :: Thread (Writer [String]) () logger = do fork helper lift $ tell ["Abort"] yield lift $ tell ["Fail"] helper :: Thread (Writer [String]) () helper = do lift $ tell ["Retry"] yield lift $ tell ["!"] 

जब हम logger चलाते हैं तो यह समय roundRobin फ़ंक्शन एक शुद्ध Writer कार्रवाई का निर्माण करता है:

 roundRobin logger :: Writer [String] () 

... और हम लॉगिंग कमांड के परिणामों को पूरी तरह से निकाल सकते हैं:

 execWriter (roundRobin logger) :: [String] 

ध्यान दें कि कैसे प्रकार शुद्ध मान की गणना करता है, हमारे मामले में String सूची। और हम अभी भी लॉग किए गए मानों की वास्तविक धाराएँ प्राप्त कर सकते हैं:

 >>> execWriter (roundRobin logger) ["Abort","Retry","Fail","!"] 

निष्कर्ष

आप सोच सकते हैं कि मैं एक धोखेबाज़ हूँ, कि मुख्य काम free पुस्तकालय में चला गया, लेकिन मैंने जो भी कार्यक्षमता का उपयोग किया है वह बहुत सामान्य कोड की 12 लाइनों में फिट हो सकता है जो कि पुनर्नवीनीकरण है।

 data FreeF fax = Pure a | Free (fx) newtype FreeT fma = FreeT { runFreeT :: m (FreeF fa (FreeT fma)) } instance (Functor f, Monad m) => Monad (FreeT fm) where return a = FreeT (return (Pure a)) FreeT m >>= f = FreeT $ m >>= \v -> case v of Pure a -> runFreeT (fa) Free w -> return (Free (fmap (>>= f) w)) instance MonadTrans (FreeT f) where lift = FreeT . liftM Pure liftF :: (Functor f, Monad m) => fr -> FreeT fmr liftF x = FreeT (return (Free (fmap return x))) 

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

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