Iteratees और FRP के बीच कनेक्शन क्या है?

Question

ऐसा लगता है कि दोनों विचारों के बीच एक मजबूत संबंध है। मेरा अनुमान है कि अगर इटरेटेस के साथ मनमाना ग्राफ व्यक्त करने का कोई तरीका होगा तो आईआरटीएटीएस के मामले में एफआरपी लागू किया जा सकता है। लेकिन afaik वे केवल चेन की तरह संरचनाओं का समर्थन करते हैं।

क्या कोई इस पर कुछ प्रकाश डाल सकता है?

Answer 1

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

data Pipe m a b = 
    Pipe { 
     cleanup :: m(), 
     feed :: [a] -> m (Maybe [b], Pipe m a b) 
    } 

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

readFile :: (MonadIO m) => FilePath -> Pipe m a ByteString 

पाइप अनुप्रयोगी functors के एक परिवार है, इसलिए धारा तत्वों के लिए एक सरल समारोह लागू करने के लिए आप सिर्फ FMAP इस्तेमाल कर सकते हैं:

fmap (B.map toUpper) . readFile 

आपकी सुविधा के लिए यह profunctors का एक परिवार भी है।

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

Answer 2

आप स्ट्रीम प्रोसेसर का उपयोग करके एफआरपी के सीमित रूप को कार्यान्वित कर सकते हैं। उदाहरण के लिए, pipes लाइब्रेरी का उपयोग कर, आप की घटनाओं का एक स्रोत से परिभाषित करें:

mouseCoordinates :: (Proxy p) =>() -> Producer p MouseCoord IO r 

... और आप इसी तरह एक ग्राफिकल हैंडलर है कि माउस निर्देशांक लेता है और एक कैनवास पर एक कर्सर को अद्यतन करता से परिभाषित करें:

coordHandler :: (Proxy p) =>() -> Consumer p MouseCoord IO r 

तो फिर तुम रचना का उपयोग कर हैंडलर करने के लिए माउस घटनाओं ऊपर हुक होगा:

>>> runProxy $ mouseCoordinates >-> coordHandler 

और यह सिर्फ आपकी अपेक्षानुसार चलाए जा सकें।

जैसा कि आपने कहा था, यह चरणों की एक श्रृंखला के लिए अच्छी तरह से काम करता है, लेकिन अधिक मनमानी टोपोलॉजी के बारे में क्या? खैर, यह पता चला है कि केंद्रीय Proxypipes का प्रकार एक मोनड ट्रांसफॉर्मर है, इसलिए आप अपने आप के ऊपर प्रॉक्सी मोनैड ट्रांसफार्मर घोंसले से किसी भी मनमाने ढंग से टोपोलॉजी का मॉडल कर सकते हैं। उदाहरण के लिए, यहां बताया गया है कि आप दो इनपुट धाराओं को कैसे ज़िप करेंगे:

zipD 
:: (Monad m, Proxy p1, Proxy p2, Proxy p3) 
=>() -> Consumer p1 a (Consumer p2 b (Producer p3 (a, b) m)) r 
zipD() = runIdentityP $ hoist (runIdentityP . hoist runIdentityP) $ forever $ do 
    a <- request()    -- Request from the outer Consumer 
    b <- lift $ request()  -- Request from the inner consumer 
    lift $ lift $ respond (a, b) -- Respond to the Producer 

यह एक करीबी कार्य की तरह व्यवहार करता है। आप इसे आंशिक रूप से प्रत्येक इनपुट पर आंशिक रूप से लागू करते हैं और फिर इसे पूर्ण रूप से लागू होने पर इसे चला सकते हैं।

>>> p3 
(1, 4) 
(2, 5) 
(3, 6) 

यह चाल किसी भी टोपोलॉजी को सामान्यीकृत:

-- 1st application 
p1 = runProxyK $ zipD <-< fromListS [1..] 

-- 2nd application 
p2 = runProxyK $ p2  <-< fromListS [4..6] 

-- 3rd application 
p3 = runProxy $ printD <-< p3 

यह सिर्फ आपकी अपेक्षानुसार चलाता है।आप "शाखाओं, ज़िपों और विलय" खंड में Control.Proxy.Tutorial में इसके बारे में बहुत अधिक जानकारी प्राप्त कर सकते हैं। विशेष रूप से, आपको fork संयोजक को यह देखना चाहिए कि यह एक उदाहरण के रूप में उपयोग करता है, जो आपको एक स्ट्रीम को दो आउटपुट में विभाजित करने देता है।