स्विफ्ट 4.1: क्यों Apple ने फ्लैट मैप का नाम बदलकर कॉम्पैक्ट मैप कर दिया

नमस्कार, हेब्र!

मेरा नाम अलेक्जेंडर ज़मीन है, मैं बुश में एक आईओएस डेवलपर हूं। यह मेरे सहकर्मी श्वेब के एक लेख का अनुवाद है, जिसमें उन्होंने बताया कि स्विफ्ट में फ़्लैटबॉल फंक्शन कैसा था और इसके एक ओवरलोड का नाम कॉम्पेक्ट मैप क्यों रखा गया था। आलेख स्विफ्ट रिपॉजिटरी और इसके विकास में होने वाली प्रक्रियाओं को समझने के साथ-साथ सामान्य विकास दोनों के लिए उपयोगी है।



कार्यात्मक प्रोग्रामिंग में, एक स्पष्ट परिभाषा है कि flatMap फ़ंक्शन क्या flatMap । flatMap विधि एक सूची और एक परिवर्तन फ़ंक्शन लेती है (जो प्रत्येक परिवर्तन के लिए शून्य या अधिक मान प्राप्त करने की अपेक्षा करता है), इसे सूची के प्रत्येक तत्व पर लागू करता है और एकल (चपटा) सूची बनाता है। यह व्यवहार सरल map फ़ंक्शन से भिन्न होता है, जो प्रत्येक मान पर एक परिवर्तन लागू करता है और प्रत्येक परिवर्तन के लिए केवल एक मान प्राप्त करने की अपेक्षा करता है।



कई संस्करणों के लिए, स्विफ्ट में एक map और flatMap map । हालाँकि, स्विफ्ट 4.1 में आप अब flatMap को मूल्यों के अनुक्रम में लागू नहीं कर सकते हैं और फिर भी एक पास को पास कर सकते हैं जो एक वैकल्पिक मान लौटाता है। इसके लिए अब एक compactMap विधि है।

पहले तो नवाचार के सार को समझना इतना आसान नहीं हो सकता है। यदि flatMap अच्छी तरह से काम करता है, तो एक अलग विधि क्यों पेश करें? चलिए इसका पता लगाते हैं।

संस्करण 4.1 से पहले स्विफ्ट मानक पुस्तकालय ने flatMap लिए ओवरलोड के तीन कार्यान्वयन प्रदान flatMap :

 1. Sequence.flatMap<S>(_: (Element) -> S) -> [S.Element],  S : Sequence 2. Optional.flatMap<U>(_: (Wrapped) -> U?) -> U? 3. Sequence.flatMap<U>(_: (Element) -> U?) -> [U] 

आइए तीनों विकल्पों पर जाएं और देखें कि वे क्या करते हैं।

Sequence.flatMap <S> (_: (तत्व) -> S) -> [S.Element], जहां S: अनुक्रम

पहला अधिभार अनुक्रमों के लिए है जिसमें एक बंद उस अनुक्रम का एक तत्व लेता है और दूसरे अनुक्रम में परिवर्तित होता है।
flatMap परिणाम के रूप में लौटे अंतिम अनुक्रम में इन सभी रूपांतरित अनुक्रमों को flatMap । उदाहरण के लिए:

 let array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] let flattened = array.flatMap { $0 } // [1, 2, 3, 4, 5, 6, 7, 8, 9] 

यह एक बेहतरीन उदाहरण है कि flatMap विधि को कैसे काम करना चाहिए। हम स्रोत सूची के प्रत्येक तत्व को बदल (नक्शा) देंगे और एक नया अनुक्रम बनाएंगे। flatMap के लिए धन्यवाद flatMap अंतिम परिणाम रूपांतरित अनुक्रमों की एक चपटा संरचना है।

Optional.flatMap <U> (_: (लिपटा) -> U?) -> U?

दूसरा अधिभार वैकल्पिक प्रकारों के लिए है। यदि आप जिस वैकल्पिक प्रकार को कॉल कर रहे हैं उसका मूल्य है, तो बंद को वैकल्पिक आवरण (अपरिवर्तित मूल्य) के बिना मूल्य के साथ बुलाया जाएगा, और आप परिवर्तित वैकल्पिक मान वापस कर सकते हैं।

 let a: Int? = 2 let transformedA = a.flatMap { $0 * 2 } // 4 let b: Int? = nil let transformedB = b.flatMap { $0 * 2 } // nil 

अनुक्रम .flatMap <U> (_: (तत्व) -> U?) -> [U]

तीसरा ओवरलोड आपको यह समझने में मदद करेगा कि compactMap किस compactMap । यह संस्करण पहले जैसा दिखता है, लेकिन एक महत्वपूर्ण अंतर है। इस स्थिति में, क्लोजर वैकल्पिक होता है। flatMap इसे संसाधित करता है, लौटे हुए शून्य मानों को लंघन करता है, और बाकी सभी को शामिल करता है - परिणामस्वरूप बिना आवरण के मान के रूप में।

 let array = [1, 2, 3, 4, nil, 5, 6, nil, 7] let arrayWithoutNils = array.flatMap { $0 } // [1, 2, 3, 4, 5, 6, 7] 

लेकिन इस मामले में, आदेश का प्रदर्शन नहीं किया गया है। इसलिए, flatMap यह संस्करण पूरी तरह से flatMap की कार्यात्मक परिभाषा की तुलना में map करीब है। और इस अधिभार के साथ समस्या यह है कि आप इसे सही तरीके से उपयोग नहीं कर सकते हैं जहां map पूरी तरह से काम करेगा।

 let array = [1, 2, 3, 4, 5, 6] let transformed = array.flatMap { $0 } // same as array.map { $0 } 

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

 struct Person { let name: String } let people = [Person(name: “Foo”), Person(name: “Bar”)] let names = array.flatMap { $0.name } 

संस्करण 4.0 से पहले स्विफ्ट में, हमें [“Foo”, “Bar”] रूपांतरण मिलेगा। लेकिन संस्करण 4.0 के साथ शुरू, स्ट्रिंग मान संग्रह प्रोटोकॉल को लागू करते हैं। इसलिए, तीसरे ओवरलोड के बजाय, इस मामले में flatMap का हमारा उपयोग पहले के अनुरूप होगा, और हमें परिवर्तित मूल्यों से एक "चपटा" परिणाम मिलेगा: [“F”, “o”, “o”, “B”, “a”, “r”]

flatMap कॉल करते flatMap आपको एक त्रुटि नहीं मिलेगी, क्योंकि यह उपयोग की अनुमति है। लेकिन तर्क को तोड़ा जाएगा, क्योंकि इसका परिणाम Array<Character>.Type है। टाइप करें, अपेक्षित Array<String>.Type नहीं - Array<String>.Type ।

निष्कर्ष

flatMap के दुरुपयोग से बचने के लिए, तीसरे ओवरलोड संस्करण को नए स्विफ्ट संस्करण से हटा दिया गया है। और उसी समस्या को हल करने के लिए ( compactMap -मानों को हटाते हुए) अब आपको एक अलग विधि का उपयोग करने की आवश्यकता है - compactMap ।