Haskell Language
क्रियाओं में सिंटैक्स

गार्ड

एक फ़ंक्शन को गार्ड का उपयोग करके परिभाषित किया जा सकता है, जिसे इनपुट के अनुसार व्यवहार को वर्गीकृत करने के बारे में सोचा जा सकता है।

निम्नलिखित फ़ंक्शन परिभाषा लें:

absolute :: Int -> Int  -- definition restricted to Ints for simplicity
absolute n = if (n < 0) then (-n) else n

हम इसे गार्ड का उपयोग करके पुनर्व्यवस्थित कर सकते हैं:

absolute :: Int -> Int
absolute n 
  | n < 0 = -n
  | otherwise = n

इस संदर्भ में otherwise True लिए एक सार्थक उर्फ है, इसलिए इसे हमेशा अंतिम गार्ड होना चाहिए।

पैटर्न मिलान

हास्केल फ़ंक्शन परिभाषा और case स्टेटमेंट के माध्यम से पैटर्न मिलान अभिव्यक्ति का समर्थन करता है।

एक केस स्टेटमेंट अन्य भाषाओं के स्विच की तरह होता है, सिवाय इसके कि यह हास्केल के सभी प्रकारों का समर्थन करता है।

चलिए शुरू करते हैं सरल:

longName :: String -> String
longName name = case name of
                   "Alex"  -> "Alexander"
                   "Jenny" -> "Jennifer"
                   _       -> "Unknown"  -- the "default" case, if you like

या, हम अपने फ़ंक्शन को एक समीकरण की तरह परिभाषित कर सकते हैं जो पैटर्न मिलान होगा, बस एक case स्टेटमेंट का उपयोग किए बिना:

longName "Alex"  = "Alexander"
longName "Jenny" = "Jennifer"
longName _       = "Unknown"

अधिक सामान्य उदाहरण Maybe प्रकार के साथ है:

data Person = Person { name :: String, petName :: (Maybe String) }

hasPet :: Person -> Bool
hasPet (Person _ Nothing) = False
hasPet _ = True  -- Maybe can only take `Just a` or `Nothing`, so this wildcard suffices

पैटर्न मिलान का उपयोग सूचियों पर भी किया जा सकता है:

isEmptyList :: [a] -> Bool
isEmptyList [] = True
isEmptyList _  = False

addFirstTwoItems :: [Int] -> [Int]
addFirstTwoItems []        = []
addFirstTwoItems (x:[])    = [x]
addFirstTwoItems (x:y:ys)  = (x + y) : ys

दरअसल, किसी भी प्रकार के क्लास के लिए किसी भी कंस्ट्रक्टर पर पैटर्न मैचिंग का इस्तेमाल किया जा सकता है। जैसे सूचियों के लिए निर्माता है : और टुपल्स के लिए ,

कहाँ और गार्ड का उपयोग करना

इस समारोह को देखते हुए:

annualSalaryCalc :: (RealFloat a) => a -> a -> String
annualSalaryCalc hourlyRate weekHoursOfWork
  | hourlyRate * (weekHoursOfWork * 52) <= 40000  = "Poor child, try to get another job"
  | hourlyRate * (weekHoursOfWork * 52) <= 120000 = "Money, Money, Money!"
  | hourlyRate * (weekHoursOfWork * 52) <= 200000 = "Ri¢hie Ri¢h"
  | otherwise = "Hello Elon Musk!"

हम उपयोग कर सकते हैं where पुनरावृत्ति से बचने के लिए और हमारे कोड अधिक पठनीय बनाने के लिए। नीचे वैकल्पिक फ़ंक्शन देखें, where का उपयोग कर:

annualSalaryCalc' :: (RealFloat a) => a -> a -> String
annualSalaryCalc' hourlyRate weekHoursOfWork
  | annualSalary <= smallSalary  = "Poor child, try to get another job"
  | annualSalary <= mediumSalary = "Money, Money, Money!"
  | annualSalary <= highSalary   = "Ri¢hie Ri¢h"
  | otherwise = "Hello Elon Musk!"
  where 
      annualSalary = hourlyRate * (weekHoursOfWork * 52)
      (smallSalary, mediumSalary, highSalary)  = (40000, 120000, 200000)

मनाया रूप में, हम इस्तेमाल किया where समारोह शरीर गणना की पुनरावृत्ति (नष्ट करने के अंत में hourlyRate * (weekHoursOfWork * 52) ) और हम भी इस्तेमाल किया where वेतन सीमा को व्यवस्थित करने के।

सामान्य उप-अभिव्यक्तियों के नामकरण को let एक्सप्रेशंस के साथ भी प्राप्त किया जा सकता है, लेकिन केवल where सिंटैक्स गार्ड्स के लिए उप-अभिव्यक्तियों का उल्लेख करना संभव बनाता है।