हैकेल

Question

में शून्य मान मुझे उपयोगकर्ता से इनपुट (एक्स) मिलता है, इसे वाई में परिवर्तित करें = (पढ़ें x) :: Int और फिर मैं फ़ंक्शन को विशेष तरीके से व्यवहार करना चाहूंगा यदि उपयोगकर्ता ने कुछ भी नहीं दिया (खाली स्ट्रिंग)।

-- In this place I would like to handle situation in which user 
-- gave empty string as argument 
-- this doesnt work :/ 
yearFilter [] y = True 

--This works fine as far as y is integer 
yearFilter x y | x == (objectYear y) = True 
       | otherwise = False 

मदद के लिए धन्यवाद, अलविदा

Answer 1

कोई शून्य जब तक आप स्पष्ट इसे परिभाषित है। आप इस तरह खाली तारों की जांच कर सकते हैं।

readInput :: IO() 
readInput = do 
    ln <- getLine 
    if valid ln 
     then -- whatever 
     else -- whatever 

valid x 
    | null x    = False 
    | not istJust convert x = False 
    | otherwise    = True 
where convert :: String -> Maybe Int 
     convert = fmap fst $ listToMaybe . reads $ "f" 

Answer 2

'पढ़ा' समारोह को पूर्णांक में कोई रिक्त स्ट्रिंग परिवर्तित नहीं कर सकते, और एक त्रुटि का कारण है, तो आप ऐसा करने की कोशिश करेंगे। आपको यह जांचने की आवश्यकता होगी कि इनपुट एक खाली स्ट्रिंग int से कनवर्ट करने से पहले है या नहीं।

let y = if null x then 0 else read x 

Answer 3

शायद आप एक Maybe प्रकार हैं: आप घटना है कि उपयोगकर्ता एक खाली स्ट्रिंग में प्रवेश करती है (जैसे 0) के रूप में एक डिफ़ॉल्ट मान का उपयोग करना चाहते हैं, तो आप कुछ इस तरह कर सकता है? यदि उपयोगकर्ता खाली स्ट्रिंग में प्रवेश करता है, तो आपका फ़ंक्शन Nothing देता है; अन्यथा यह Just n देता है, जहां n उपयोगकर्ता द्वारा दर्ज किया गया है?

userInt :: String -> Maybe Int 
userInt [] = Nothing 
userInt s = Just $ read s 

(मैं इस कोड संकलित नहीं किया है।)

Answer 4

इस मामले में, Maybe पर्याप्त नहीं हो सकता है:

1. उपयोगकर्ता कुछ भी नहीं
में प्रवेश किया: आप तीन शर्तों के बारे में चिंता करने की ज़रूरत
2. उपयोगकर्ता इनपुट मान्य था
3. उपयोगकर्ता इनपुट अवांछनीय

यह डेटा प्रकार और समारोह इस सीधे व्यक्त:

data Input a = NoInput | Input a | BadInput String 
    deriving (Eq, Show) 

input :: (Read a) => String -> Input a 
input "" = NoInput 
input s = 
    case filter (null.snd) (reads s) of 
     ((a,_):_) -> Input a 
     otherwise -> BadInput s 

नोट बल्कि अधूरा समारोह read का उपयोग करने से, यह reads का उपयोग करता है जो इनपुट पर त्रुटि नहीं है जो नहीं बदला जा सकता होगा। reads में कुछ हद तक अजीब इंटरफ़ेस है, हां, इसलिए मैं लगभग हमेशा उस फ़ंक्शन में लपेटता हूं जो Maybe a या यहां कुछ ऐसा देता है।

उदाहरण उपयोग:

> input "42" :: Input Int 
Input 42 
> input "cat" :: Input Int 
BadInput "cat" 
> input "" :: Input Int 
NoInput 

---

मैं इस तरह अपने yearFilter समारोह कोड होगा:

yearFilter :: Maybe Int -> Int -> Bool 
yearFilter Nothing _ = True 
yearFilter (Just x) y = x == objectYear y 

तब मैं उपयोगकर्ता इनपुट संभाल चाहते हैं के रूप में:

inputToMaybe :: Input a -> Maybe a 
inputToMaybe (Input a) = Just a 
inputToMaybe _   = Nothing 

do 
    a <- input `fmap` getLine 
    case a of 
     BadInput s -> putStrLn ("Didn't understand " ++ show s) 
     otherwise -> ... yearFilter (inputToMaybe a) .... 

एनबी : मैंने साफ कर लिया है कोड yearFilter में थोड़ा सा: परीक्षण से बूलियन का उत्पादन करने के लिए गार्ड का उपयोग करने की आवश्यकता नहीं है - बस परीक्षण, फ़ंक्शन एप्लिकेशन (objectYear) ऑपरेटर (==) से अधिक कठोर बांधता है ताकि हटाए गए कोष्ठक को _ के साथ अप्रयुक्त इनपुट के नामों को प्रतिस्थापित किया जा सके।

---

ठीक है, मैं मानता मैं अपने आप को मदद नहीं कर सकता .... मैं एक बार फिर yearFilter फिर से लिख दिया, इस बार के रूप में मैं झुका दिया जाएगा यह लिखने के लिए:

yearFilter :: Maybe Int -> Int -> Bool 
yearFilter x y = maybe True (== objectYear y) x 

Maybe के बारे में सीखना और maybe हास्केल के बारे में पहली बात थी जिसने मुझे वास्तव में भाषा से प्यार किया।