Haskell Language
टुपल्स (जोड़े, त्रिभुज, ...)

टिप्पणियों

टपल मूल्यों का निर्माण

टुपल्स बनाने के लिए कोष्ठक और अल्पविराम का उपयोग करें। एक जोड़ी बनाने के लिए एक अल्पविराम का उपयोग करें।

(1, 2)

अधिक घटकों के साथ टुपल्स बनाने के लिए अधिक कॉमा का उपयोग करें।

(1, 2, 3)

(1, 2, 3, 4)

ध्यान दें कि उनके अनप्लग्ड रूप में उपयोग करके ट्यूपल्स को घोषित करना भी संभव है।

(,) 1 2     -- equivalent to (1,2)
(,,) 1 2 3  -- equivalent to (1,2,3)

टुपल्स में विभिन्न प्रकार के मूल्य हो सकते हैं।

("answer", 42, '?')

ट्यूपल्स में जटिल मान हो सकते हैं जैसे सूचियां या अधिक ट्यूपल।

([1, 2, 3], "hello", ('A', 65))

(1, (2, (3, 4), 5), 6)

टपल टाइप लिखें

छोटे प्रकार लिखने के लिए कोष्ठक और अल्पविराम का उपयोग करें। एक जोड़ी प्रकार लिखने के लिए एक अल्पविराम का उपयोग करें।

(Int, Int)

अधिक घटकों के साथ टपल प्रकार लिखने के लिए अधिक कॉमा का उपयोग करें।

(Int, Int, Int)

(Int, Int, Int, Int)

टुपल्स में विभिन्न प्रकार के मूल्य हो सकते हैं।

(String, Int, Char)

ट्यूपल्स में जटिल मान हो सकते हैं जैसे सूचियां या अधिक ट्यूपल।

([Int], String, (Char, Int))

(Int, (Int, (Int, Int), Int), Int)

टुपल्स पर पैटर्न मैच

ट्यूपल्स पर पैटर्न का मिलान टपल निर्माणकर्ताओं का उपयोग करता है। उदाहरण के लिए एक जोड़ी का मिलान करने के लिए, हम निर्माणकर्ता (,) उपयोग करेंगे:

myFunction1 (a, b) = ...

हम अधिक घटकों के साथ ट्यूपल्स का मिलान करने के लिए अधिक अल्पविराम का उपयोग करते हैं:

myFunction2 (a, b, c) = ...

myFunction3 (a, b, c, d) = ...

ट्यूपल पैटर्न में जटिल पैटर्न हो सकते हैं जैसे सूची पैटर्न या अधिक ट्यूपल पैटर्न।

myFunction4 ([a, b, c], d, e) = ...

myFunction5 (a, (b, (c, d), e), f) = ...

टपल घटकों को निकालें

जोड़े के पहले और दूसरे घटक को निकालने के लिए fst और snd फ़ंक्शन ( Prelude या Data.Tuple ) का उपयोग करें।

fst (1, 2) -- evaluates to 1

snd (1, 2) -- evaluates to 2

या पैटर्न मिलान का उपयोग करें।

case (1, 2) of (result, _) => result -- evaluates to 1

case (1, 2) of (_, result) => result -- evaluates to 2

पैटर्न मिलान दो से अधिक घटकों के साथ टुपल्स के लिए भी काम करता है।

case (1, 2, 3) of (result, _, _) => result -- evaluates to 1

case (1, 2, 3) of (_, result, _) => result -- evaluates to 2

case (1, 2, 3) of (_, _, result) => result -- evaluates to 3

हास्केल दो से अधिक घटकों के साथ ट्यूपल्स के लिए fst या snd जैसे मानक कार्य प्रदान नहीं करता है। Hackage पर tuple Library Data.Tuple.Select मॉड्यूल में ऐसे कार्य प्रदान करता है।

एक द्विआधारी कार्य को एक ट्यूपल पर लागू करें (अपरिवर्तनशील)

बाइनरी फ़ंक्शन को ट्यूपल्स पर एक फ़ंक्शन में परिवर्तित करने के लिए uncurry फ़ंक्शन ( Prelude या Data.Tuple ) का उपयोग करें।

uncurry (+) (1, 2) -- computes 3

uncurry map (negate, [1, 2, 3]) -- computes [-1, -2, -3]

uncurry uncurry ((+), (1, 2)) -- computes 3

map (uncurry (+)) [(1, 2), (3, 4), (5, 6)] -- computes [3, 7, 11]

uncurry (curry f) -- computes the same as f

दो तर्कों के लिए एक ट्यूल समारोह लागू करें (करी)

एक फ़ंक्शन को बदलने के लिए curry फ़ंक्शन ( Prelude या Data.Tuple ) का उपयोग करें जो ट्यूपल्स को एक फ़ंक्शन में ले जाता है जो कई तर्क लेता है।

curry fst 1 2 -- computes 1

curry snd 1 2 -- computes 2

curry (uncurry f) -- computes the same as f

import Data.Tuple (swap)
curry swap 1 2 -- computes (2, 1)

स्वैप जोड़ी घटक

एक जोड़ी के घटकों को स्वैप करने के लिए swap ( Data.Tuple ) का उपयोग करें।

import Data.Tuple (swap)
swap (1, 2) -- evaluates to (2, 1)

या पैटर्न मिलान का उपयोग करें।

case (1, 2) of (x, y) => (y, x) -- evaluates to (2, 1)

एक टपल मिलान की कठोरता

पैटर्न (p1, p2) सबसे बाहरी ट्यूपल निर्माता में सख्त है, जिससे अप्रत्याशित कठोरता व्यवहार हो सकता है । उदाहरण के लिए, निम्न अभिव्यक्ति का विचलन होता है ( Data.Function.fix का उपयोग Data.Function.fix ):

fix $ \(x, y) -> (1, 2)

चूंकि मिलान पर (x, y) टुपल कंस्ट्रक्टर में सख्त है। हालाँकि, निम्नलिखित अभिव्यक्ति, एक अकाट्य पैटर्न का उपयोग करते हुए (1, 2) उम्मीद के अनुसार (1, 2) मूल्यांकन करती है:

fix $ \ ~(x, y) -> (1, 2)