Netwire कार्यक्रमों

Question

मैं Netwire संस्करण 5.

के साथ शुरू हो रही मैं सभी तारों मैं अपने आउटपुट में मेरी आदानों बदलना चाहते हैं लिख कोई समस्या नहीं है में इनपुट हो रही है।

अब आईओ रैपर को मेरे असली दुनिया के इनपुट में जोड़ने के लिए समय आ गया है, और मैं थोड़ा उलझन में हूं।

क्या मुझे sWire s e m a b के पैरामीटर के लिए कस्टम सत्र प्रकार बनाना है और वहां मेरे सेंसर मान एम्बेड करना है?

1. class (Monoid s, Real t) => HasTime t s | s -> t की Monoid s संदर्भ के साथ क्या है:

   यदि हां, तो मैं इन प्रश्न हैं? इसका क्या उपयोग है?

2. मैं अपने सेंसर रीडिंग के साथ Map String Double पर काम करने की सोच रहा था, लेकिन मेरे monoid शब्दकोशों को कैसे क्रंच करना चाहिए? क्या इसे बाएं पक्षपातपूर्ण होना चाहिए? राइट-पक्षपाती? इनमे से कोई भी नहीं?

यदि नहीं, तो मुझे क्या करना चाहिए? मैं अपने इनपुट का प्रतिनिधित्व करते हुए s के लिए फॉर्म Wire s InhibitionReason Identity() Double के तारों के साथ समाप्त करना चाहता हूं।

यह मेरी समझ है कि मैं नहीं चाहता या इस उद्देश्य के लिए Wire की monadic m पैरामीटर का उपयोग करने की आवश्यकता है, तारों के लिए खुद को शुद्ध होने के लिए अनुमति देता है और कोड है कि शीर्ष स्तर के तार के माध्यम से कदम के लिए आईओ सीमित (है रों)। क्या यह गलत है?

Answer 1

Wire s e m a b में डेटा डालने का सबसे आसान तरीका इनपुट a के माध्यम से है। राज्य डेल्टा s या अंतर्निहित Monadm से डेटा प्राप्त करने के लिए WPure या WGen के उपयोग के माध्यम से संभव है, लेकिन ये हमें मुख्य अवशेषों से आगे ले जाते हैं। मुख्य अवशोषण Arrow और Category हैं, जो केवल a b के बारे में जानते हैं, और s e m के बारे में नहीं जानते हैं।

यहां एक बहुत ही सरल कार्यक्रम का उदाहरण दिया गया है, इनपुट इनपुट a के रूप में इनपुट प्रदान करना। double कार्यक्रम का बाहरीतम तार है। repl एक छोटा सा पठन-eval-print लूप है जो तार चलाने के लिए stepWire पर कॉल करता है।

import FRP.Netwire 
import Control.Wire.Core 

import Prelude hiding (id, (.)) 

double :: Arrow a => a [x] [x] 
double = arr (\xs -> xs ++ xs) 

repl :: Wire (Timed Int()) e IO String String -> IO() 
repl w = do 
    a <- getLine 
    (eb, w') <- stepWire w (Timed 1()) (Right a) 
    putStrLn . either (const "Inhibited") id $ eb 
    repl w' 

main = repl double 

सूचना है कि हम stepWire के लिए समय अंतर में गुजरती हैं, न की कुल बीता हुआ समय। हम जांच सकते हैं कि एक अलग शीर्ष-स्तरीय तार चलाकर यह सही काम है।

timeString :: (HasTime t s, Show t, Monad m) => Wire s e m a String 
timeString = arr show . time 

main = repl timeString 

कौन सा वांछित आउटपुट है:

a 
1 
b 
2 
c 
3 

Answer 2

मैं सिर्फ एक तीर तरीके से इस हल, तो यह अधिक composible हो सकता है। यदि आप चाहें तो आप मेरी पोस्ट पढ़ सकते हैं। Kleisli Arrow in Netwire 5? और Console interactivity in Netwire?।दूसरे पोस्ट एक पूरा इंटरेक्टिव प्रोग्राम

सबसे पहले है, तो आप इस की जरूरत है Kleisli कार्य (, कुछ भी a -> m b यही कारण है) लिफ्ट करने के लिए:

mkKleisli :: (Monad m, Monoid e) => (a -> m b) -> Wire s e m a b 
mkKleisli f = mkGen_ $ \a -> liftM Right $ f a 

फिर, यह सोचते हैं आप टर्मिनल से पात्रों प्राप्त करना चाहते हैं, तो आप उठा सकते हैं hGetChar ऐसा करके:

inputWire :: Wire s() IO() Char 
inputWire = mkKleisli $ \_ -> hGetChar stdin 

मैं इस runWire समारोह का परीक्षण नहीं किया (मैं सिर्फ अपनी पिछली पोस्ट से बंद कोड छीन), लेकिन यह अपने तारों चलाना चाहिए:

+०१२३५१६४१०६१

runWire :: (Monad m) => Session m s -> Wire s e m()() -> m() 
runWire s w = do 
    (ds, s') <- stepSession s 
    -- | You don't really care about the() returned 
    (_, w') <- stepWire w ds (Right()) 
    runWire s' w' 

जहां भी आप किसी अन्य तार या तीर की तरह आप इनपुट तार लिख सकते हैं।

mainWire = proc _ -> do 
    c <- inputWire -<() 
    q <- quitWire -< c 
    outputWire -< c 
    returnA -< q 

या, एक लाइनर:

mainWire = inputWire >>> (quitWire &&& outputWire) >>> arr (\(q,_) -> q)