हास्केल: वास्तविक समय में एक हैंडल की सामग्री को दूसरे में कैसे पाइप करें

Question

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

main = do processInfo <- createProcess (proc "ghci" []){std_out = CreatePipe, 
                std_in = CreatePipe } 
     case processInfo of 
      (Just hIn, Just hOut, _, _) -> do mainloop hIn hOut 
              hClose hIn 
              hClose hOut 
     _        -> do error "Unable to start process" 

mainloop :: Handle -> Handle -> IO() 
mainloop inh outh = 
    do ineof <- hIsEOF outh 
     if ineof 
      then return() 
      else do inpStr <- hGetLine outh 
        putStrLn inpStr 
        mainloop inh outh 

लेकिन यह काम नहीं करता है, क्योंकि यह केवल लाइन द्वारा उत्पादन लाइन को पहचानता है, ताकि एक नई पंक्ति द्वारा समाप्त नहीं किया गया है प्रक्रियाओं उत्पादन संभाल पर किसी भी उत्पादन नहीं दिखाई देता है । मैंने hGetContents के साथ एक ही चीज़ की कोशिश की है लेकिन यह एक ही परिणाम उत्पन्न करता है। मैंने सिस्टम.प्रोसेस और सिस्टम.आईओ दोनों के दस्तावेज के माध्यम से पढ़ा है और वास्तव में कुछ भी निर्णायक नहीं मिला है।

Answer 1

hSetBuffering आप के लिए, डिफ़ॉल्ट जो खोज रहे हैं (यूनिक्स पर कम से कम) लाइन बफरिंग है। उत्पादन हैंडल पर stdin पर इसका इस्तेमाल मुख्य लूप

hSetBuffering hIn NoBuffering 

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

Answer 2

मैं बहुत ज्यादा एक हास्केल नौसिखिया हूँ, लेकिन मैं प्रसंस्करण इनपुट चरित्र-दर-चरित्र की हाल ही में एक उदाहरण भर में आ रहा याद है। hSetBuffering संभवतः आप क्या देख रहे हैं?

Answer 3

बफरिंग एक बात है, लेकिन आप gGetLine का भी उपयोग कर रहे हैं जो पूरी लाइन (या फ़ाइल के अंत) की प्रतीक्षा करेगा। hGetChar का उपयोग करने पर विचार करें यदि आप वास्तव में उस समय एक चरित्र पढ़ना चाहते हैं। और बीटीडब्ल्यू, बफरिंग पर काबू पाने का एक और तरीका hFlush का उपयोग करना है।