हास्केल प्रोग्राम

Question

की प्रगति दिखाएं मेरे पास कुछ ऑब्जेक्ट्स के साथ हास्केल में सूची है। और मुझे यह पता लगाना होगा कि इनमें से कोई वस्तु कुछ शर्त को संतुष्ट करती है या नहीं।

any (\x -> check x) xs 

लेकिन समस्या यह है कि चेक आपरेशन बहुत महंगा है, और सूची काफी बड़ी है: तो, मैं निम्नलिखित लिखा था। मैं रनटाइम में वर्तमान प्रगति देखना चाहता हूं, उदाहरण के लिए 50% (1000/2000 checked).
मैं यह कैसे कर सकता हूं?

Answer 1

चूंकि आप अपने फ़ंक्शन की प्रगति देखना चाहते हैं (जो फ़ंक्शन का दुष्प्रभाव है) सबसे स्पष्ट समाधान मोनैड का उपयोग करना है। ऐसा करने के लिए पहली बात यह है any समारोह की एक monadic संस्करण बनाने के लिए है:

anyM :: (Monad m) => (a -> m Bool) -> [a] -> m Bool 
anyM _ []  = return False 
anyM pred (x:xs) = reduce (pred x) xs 
    where reduce acc []  = acc 
      reduce acc (x:xs) = do 
       condition <- acc 
       if condition 
        then return condition 
        else reduce (pred x) xs 

ऊपर समारोह anyMany समारोह की एक monadic संस्करण है। यह हमें यह जांचने के अलावा दुष्प्रभाव उत्पन्न करने की अनुमति देता है कि दी गई सूची में कोई भी वस्तु दी गई भविष्यवाणी को पूरा करती है या नहीं।

anyVar :: (a -> Bool) -> [a] -> IO Bool 
anyVar pred xs = anyM check $ zip [1..] xs 
    where check (n,x) = do 
      putStrLn $ show n ++ " checked. " 
      return $ pred x 

सूचना है कि क्योंकि हम लंबाई पता नहीं है:

हम एक और समारोह जो any फ़ंक्शन को निष्पादित करने के रूप में इस के अलावा एक पक्ष प्रभाव के रूप में एक प्रगति बार प्रदर्शित करता है बनाने के लिए anyM समारोह का उपयोग कर सकते सूची में से पहले हम केवल सूची में आइटम की संख्या प्रदर्शित करते हैं। हम सूची में आइटम्स की संख्या पता है पहले से तो हम एक अधिक सूचनात्मक प्रगति बार प्रदर्शित कर सकते हैं:

anyFix :: (a -> Bool) -> Int -> [a] -> IO Bool 
anyFix pred length xs = anyM check $ zip [1..] xs 
    where check (n,x) = do 
      putStrLn $ show (100 * n `div` length) ++ "% (" ++ 
       show n ++ "/" ++ show length ++ " checked). " 
      return $ pred x 

अनंत सूचियों के लिए और सूचियों जिसकी लंबाई आप पहले से पता नहीं है के लिए anyVar समारोह का उपयोग करें। सीमित सूचियों के लिए anyFix फ़ंक्शन का उपयोग करें जिनकी लंबाई आप पहले से जानते हैं।

यदि सूची बड़ी है और आप पहले सूची की लंबाई नहीं जानते हैं तो length फ़ंक्शन को इसकी लंबाई निर्धारित करने के लिए संपूर्ण सूची को पार करने की आवश्यकता होगी। इसलिए इसके बजाय anyVar का उपयोग करना बेहतर होगा।

अंत में रैप करने के लिए यह यह सब कैसे आप ऊपर कार्यों का उपयोग होता है:

main = anyFix (==2000) 2000 [1..2000] 

आपके मामले में आप के बजाय निम्न कर सकता है:

main = anyVar check xs 

आशा इस जवाब आप मदद की।

Answer 2

सबसे अनुभवहीन और सीधा रास्ता लागू करने के लिए है अपने स्वयं के

anyM :: (a -> Bool) -> [a] -> IO Bool 

कि प्रगति बार प्रिंट (जैसे terminal-progress-bar का उपयोग)।

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

भी है कि आप (जैसे any के रूप में) एक शुद्ध गणना की निगरानी एक उदाहरण के लिए bytestring-progress देखने की अनुमति देता unsafePerformIO और unsafeInterleaveIO का उपयोग कर दृष्टिकोण हैं। लेकिन यह संदिग्ध डिज़ाइन है कि आपको केवल तभी उपयोग करना चाहिए यदि आप जानते हैं कि आप परिणामों को समझते हैं।

Answer 3

ऐसा करने का एक और तरीका स्ट्रीमिंग लाइब्रेरी का उपयोग कर रहा है जैसे conduit या pipes। , आप अगर

import Pipes 
import qualified Pipes.Prelude as P 

bigList :: [Int] 
bigList = [1,2,3,4] 

check :: Int -> Bool 
check = (>3) 

main :: IO() 
main = do 
    result <- P.any check $ each bigList >-> P.chain (\_ -> putStrLn ".") 
    putStrLn . show $ result 

अब यहाँ कुछ नमूना है जो एक डॉट हर बार सूची का एक तत्व जांच की जानी आता प्रिंट pipes का उपयोग कर कोड, है (each पाइप्स मॉड्यूल से एक समारोह है।) प्रतिशत दिखाने के लिए चाहता था, P.chain (\_ -> putStrLn ".") पाइपलाइन का हिस्सा थोड़ा अधिक स्मार्ट होना चाहिए। इसे वर्तमान प्रतिशत को राज्य के रूप में ले जाना होगा, और सूची की लंबाई पता होना चाहिए। (। यदि आपकी सूची विशाल और lazily उत्पन्न है, इसकी लंबाई की गणना के अपने मूल्यांकन के लिए मजबूर है और संभवत: समस्या का कारण बन आप पहले से ही स्मृति में है, तो यह नहीं बड़ी समस्या होगी।)

संपादित करें: यहाँ

{-# LANGUAGE FlexibleContexts #-} 

import Pipes 
import qualified Pipes.Prelude as P 
import Data.Function 
import Control.Monad.RWS 

bigList :: [Int] 
bigList = [1,2,3,4] 

check :: Int -> Bool 
check = (>3) 

-- List length is the environment, number of received tasks is the state. 
tracker :: (MonadReader Int m, MonadState Int m, MonadIO m) => Pipe a a m r 
tracker = P.chain $ \_ -> do 
    progress <- on (/) fromIntegral `liftM` (modify succ >> get) `ap` ask 
    liftIO . putStrLn . show $ progress 

main :: IO() 
main = do 
    (result,()) <- evalRWST (P.any check $ each bigList >-> tracker) 
          (length bigList) -- list length as unchanging environment 
          0 -- initial number of received tasks (the mutable state) 
    putStrLn . show $ result 

आगे यह भी केवल महत्वपूर्ण प्रतिशत बढ़ जाती है को दिखाने के लिए परिष्कृत हो सकता है: पिछले कोड का एक संभव विस्तार है कि वास्तव में प्रतिशत से पता चलता है।

Answer 4

मैं सिर्फ Debug.Trace.trace का उपयोग और इतने की तरह वर्तमान स्थिति का ट्रैक रखने होगा:

any (\(i,x) -> trace (showProgress i (length xs)) $ check x) $ zip [1..] xs 

Answer 5

आप explicit-exception:Control.Monad.Execption.Synchronous या transformers:Control.Monad.Trans.Maybe तरह स्पष्ट अपवाद के लिए एक पुस्तकालय का उपयोग कर सकते हैं, जब आप एक तत्व पाया जाता है और "एक अपवाद फेंक" है कि चेक पास करता है।