Haskell Language
आंशिक आवेदन
खोज…
टिप्पणियों
चलो कुछ गलत धारणाओं को स्पष्ट करते हैं जो शुरुआती कर सकते हैं।
आपको इस तरह के कार्यों का सामना करना पड़ा हो सकता है:
max :: (Ord a) => a -> a -> a
max m n
| m >= n = m
| otherwise = n
शुरुआती आमतौर पर max :: (Ord a) => a -> a -> a फ़ंक्शन है जो टाइप a दो तर्क (मान) लेता a और टाइप a का मान लौटाता a । हालाँकि, जो वास्तव में हो रहा है, वह यह है कि max एक प्रकार का एक तर्क ले रहा a और प्रकार का एक फ़ंक्शन लौटा रहा a -> a । यह फ़ंक्शन तब a का तर्क लेता a और प्रकार a का अंतिम मान लौटाता a ।
दरअसल, max को max :: (Ord a) => a -> (a -> a) रूप में लिखा जा सकता है max :: (Ord a) => a -> (a -> a)
max के प्रकार पर विचार करें:
Prelude> :t max
max :: Ord a => a -> a -> a
Prelude> :t (max 75)
(max 75) :: (Num a, Ord a) => a -> a
Prelude> :t (max "Fury Road")
(max "Fury Road") :: [Char] -> [Char]
Prelude> :t (max "Fury Road" "Furiosa")
(max "Fury Road" "Furiosa") :: [Char]
max 75 और max "Fury Road" कार्यों की तरह नहीं दिख सकते हैं, लेकिन वास्तविकता में, वे हैं।
भ्रम इस तथ्य से उपजा है कि गणित और कई, अन्य, सामान्य प्रोग्रामिंग भाषाओं में, हमें कई तर्क लेने वाले कार्य करने की अनुमति है। हालांकि, हास्केल में, कार्य केवल एक तर्क ले जा सकते हैं और वे इस तरह के रूप में या तो मानों लौट सकते हैं a तरह के रूप में काम करता है, या a -> a ।
आंशिक रूप से लागू फंक्शन
हम पहले तर्क को "लॉक" करने के लिए आंशिक एप्लिकेशन का उपयोग कर सकते हैं। एक तर्क लागू करने के बाद हमें एक फ़ंक्शन के साथ छोड़ दिया जाता है, जो परिणाम लौटने से पहले एक और तर्क की अपेक्षा करता है।
(+) :: Int -> Int -> Int
addOne :: Int -> Int
addOne = (+) 1
हम तो उपयोग कर सकते हैं addOne क्रम में एक करने के लिए एक जोड़ने के लिए Int ।
> addOne 5
6
> map addOne [1,2,3]
[2,3,4]
आंशिक रूप से लागू फ़ंक्शन लौटना
आंशिक रूप से लागू किए गए कार्यों को वापस करना संक्षिप्त कोड लिखने की एक तकनीक है।
add :: Int -> Int -> Int
add x = (+x)
add 5 2
इस उदाहरण में (+ x) आंशिक रूप से लागू फ़ंक्शन है। ध्यान दें कि फ़ंक्शन को जोड़ने के लिए दूसरा पैरामीटर फ़ंक्शन परिभाषा में निर्दिष्ट करने की आवश्यकता नहीं है।
कॉल add 5 2 का परिणाम सात है।
धारा
आंशिक रूप से इन्फिक्स ऑपरेटरों के लिए तर्कों को लागू करने के लिए सेक्शनिंग एक संक्षिप्त तरीका है।
उदाहरण के लिए, यदि हम एक फ़ंक्शन लिखना चाहते हैं जो एक शब्द के अंत में "आईएनजी" जोड़ता है, तो हम किसी फ़ंक्शन को सफलतापूर्वक परिभाषित करने के लिए एक अनुभाग का उपयोग कर सकते हैं।
> (++ "ing") "laugh"
"laughing"
ध्यान दें कि हमने दूसरे तर्क को आंशिक रूप से कैसे लागू किया है। आम तौर पर, हम केवल निर्दिष्ट क्रम में तर्कों को आंशिक रूप से लागू कर सकते हैं।
हम पहले तर्क को आंशिक रूप से लागू करने के लिए बाएं सेक्शनिंग का भी उपयोग कर सकते हैं।
> ("re" ++) "do"
"redo"
हम सामान्य रूप से उपसर्ग आंशिक अनुप्रयोग का उपयोग करके इसे समान रूप से लिख सकते हैं:
> ((++) "re") "do"
"redo"
घटाव पर एक नोट
शुरुआती अक्सर गलत तरीके से खंडन करते हैं।
> map (-1) [1,2,3]
***error: Could not deduce...
यह काम नहीं करता है क्योंकि -1 सेक्शन ऑपरेटर के बजाय शाब्दिक -1 रूप में पार्स किया जाता है - 1 लागू होता है। इस मुद्दे को दरकिनार करने के लिए subtract समारोह मौजूद है।
> map (subtract 1) [1,2,3]
[0,1,2]
