फंक्शनल स्विफ्ट आसान है

कार्यात्मक प्रोग्रामिंग के बारे में लेख बहुत कुछ लिखते हैं कि एफपी दृष्टिकोण कैसे विकास में सुधार करता है: लेखन, पढ़ना, स्ट्रीम, कोड, टेस्ट, बिल्ड आर्किटेक्चर लिखना आसान हो जाता है और बाल मुलायम और रेशमी हो जाते हैं ।

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

फिर मैंने शुरू से ही एफपी का पता लगाने का फैसला किया। मैंने पता लगाया और कोडफेस्ट को बताया कि एफपी वास्तव में सिर्फ इतना है कि हम पहले से ही स्विफ्ट में इसका उपयोग करते हैं और इसे और भी अधिक कुशलता से उपयोग कर सकते हैं।

कार्यात्मक प्रोग्रामिंग: शुद्ध कार्य और राज्यों की कमी

यह निर्धारित करना कि किसी विशेष प्रतिमान में लिखने का क्या मतलब है, यह एक आसान काम नहीं है। प्रतिमानों का निर्माण दशकों से विभिन्न दृष्टियों वाले लोगों द्वारा किया गया है, जो असंतुष्ट दृष्टिकोण वाली भाषाओं में सन्निहित हैं, और औजारों से घिरे हैं। इन उपकरणों और दृष्टिकोणों को प्रतिमानों का एक अभिन्न अंग माना जाता है, लेकिन वास्तव में वे नहीं हैं।

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

नतीजतन, यह पता चला है कि यह स्पष्ट रूप से निर्धारित करना असंभव है कि एक विशेष प्रतिमान क्या है। एक बार फिर, मैं 2019 में कोडफेस्ट में आया, जहां सभी एफपी विशेषज्ञ, कार्यात्मक प्रतिमान के बारे में बोलते हुए, विभिन्न चीजों को कहते हैं।

व्यक्तिगत रूप से, मुझे विकि से परिभाषा पसंद आई:

"कार्यात्मक प्रोग्रामिंग असतत गणित और एक प्रोग्रामिंग प्रतिमान का एक खंड है जिसमें गणना प्रक्रिया को उत्तरार्द्ध की गणितीय समझ में कार्यों के मूल्यों की गणना के रूप में माना जाता है (प्रक्रियात्मक प्रोग्रामिंग में उपप्रोग्राम के रूप में कार्यों के विपरीत)।"

गणितीय कार्य क्या है? यह एक फ़ंक्शन है जिसका परिणाम केवल उस डेटा पर निर्भर करता है जिस पर इसे लागू किया जाता है।

कोड की चार लाइनों में गणितीय फ़ंक्शन का एक उदाहरण इस तरह दिखता है:

func summ(a: Int, b: Int) -> Int { return a + b } let x = summ(a: 2, b: 3) 

इनपुट तर्कों 2 और 3 के साथ योग समारोह, हम 5 प्राप्त करते हैं। यह परिणाम अपरिवर्तित है। प्रोग्राम, थ्रेड, निष्पादन का स्थान बदलें - परिणाम समान रहेगा।

और एक गैर-गणितीय फ़ंक्शन तब होता है जब एक वैश्विक चर कहीं घोषित किया जाता है।

 var z = 5 

योग फ़ंक्शन अब इनपुट तर्कों और z के मूल्य को जोड़ता है।

 func summ(a: Int, b: Int) -> Int { return a + b + z } let x = summ(a: 2, b: 3) 

वैश्विक राज्य पर निर्भरता बढ़ गई। अब एक्स के मूल्य को स्पष्ट रूप से अनुमानित करना असंभव है। जब फ़ंक्शन को कॉल किया गया था, उसके आधार पर यह लगातार बदलता रहेगा। हम फ़ंक्शन को एक पंक्ति में 10 बार कहते हैं, और हर बार हम एक अलग परिणाम प्राप्त कर सकते हैं।

गैर-गणितीय फ़ंक्शन का दूसरा संस्करण:

 func summ(a: Int, b: Int) -> Int { z = b - a return a + b } 

इनपुट तर्कों के योग को वापस करने के अलावा, फ़ंक्शन वैश्विक चर z बदलता है। इस सुविधा का एक साइड इफेक्ट है।

कार्यात्मक प्रोग्रामिंग में गणितीय कार्यों के लिए एक विशेष शब्द है - शुद्ध कार्य। एक शुद्ध फ़ंक्शन एक फ़ंक्शन है जो इनपुट मानों के समान सेट के लिए एक ही परिणाम देता है और इसके साइड इफेक्ट नहीं होते हैं।

शुद्ध कार्य एफपी की आधारशिला हैं, बाकी सब कुछ गौण है। यह माना जाता है कि, इस प्रतिमान के बाद, हम केवल उनका उपयोग करते हैं। और यदि आप वैश्विक या परिवर्तनशील राज्यों के साथ काम नहीं करते हैं, तो वे आवेदन में नहीं होंगे।

एक कार्यात्मक प्रतिमान में कक्षाएं और संरचनाएं

प्रारंभ में, मैंने सोचा था कि एफपी केवल कार्यों के बारे में है, और कक्षाएं और संरचनाएं केवल ओओपी में उपयोग की जाती हैं। लेकिन यह पता चला कि कक्षाएं भी एफपी की अवधारणा में फिट होती हैं। केवल उन्हें होना चाहिए, आइए हम कहते हैं, "साफ"।

एक "शुद्ध" वर्ग एक वर्ग है, जिसके सभी तरीके शुद्ध कार्य हैं, और गुण अपरिवर्तनीय हैं। (यह एक अनौपचारिक शब्द है, जो रिपोर्ट की तैयारी में गढ़ा गया है)।

इस वर्ग पर एक नज़र डालें:

 class User { let name: String let surname: String let email: String func getFullname() -> String { return name + " " + surname } } 

इसे डाटा इनकैप्सुलेशन माना जा सकता है ...

 class User { let name: String let surname: String let email: String } 

और उनके साथ काम करने के लिए कार्य करता है।

 func getFullname() -> String { return name + " " + surname } 

एफपी के दृष्टिकोण से, उपयोगकर्ता वर्ग का उपयोग करना आदिम और कार्यों के साथ काम करने से अलग नहीं है।

मूल्य घोषित करें - उपयोगकर्ता वान्या।

 let ivan = User( name: "", surname: "", email: "ivanov@example.com" ) 

इसके लिए getFullname फ़ंक्शन लागू करें।

 let fullName = ivan.getFullname() 

परिणामस्वरूप, हमें एक नया मान मिलता है - पूर्ण उपयोगकर्ता नाम। चूंकि आप ivan प्रॉपर्टी के मापदंडों को नहीं बदल सकते हैं, इसलिए getFullname कॉल करने का परिणाम अपरिवर्तित है।

बेशक, एक चौकस पाठक कह सकता है: "एक मिनट रुको, getFullname विधि इसके लिए वैश्विक मूल्यों के आधार पर परिणाम लौटाता है - वर्ग गुण, तर्क नहीं।" लेकिन वास्तव में एक विधि सिर्फ एक फ़ंक्शन है जिसमें एक ऑब्जेक्ट को एक तर्क के रूप में पारित किया जाता है।

स्विफ्ट भी इस प्रविष्टि का स्पष्ट समर्थन करती है:

 let fullName = User.getFullname(ivan)() 

अगर हमें ऑब्जेक्ट के कुछ मूल्य को बदलने की आवश्यकता है, उदाहरण के लिए ईमेल, तो हमें एक नई वस्तु बनानी होगी। यह उपयुक्त विधि द्वारा किया जा सकता है।

 class User { let name: String let surname: String let email: String func change(email: String) -> User { return User(name: name, surname: surname, email: email) } } let newIvan = ivan.change(email: "god@example.com") 

स्विफ्ट में कार्यात्मक गुण

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

मजबूत टाइपिंग और प्रकार का अनुमान स्विफ्ट का हिस्सा है। उन्हें परियोजना को समझने या पेश करने की आवश्यकता नहीं है, हमारे पास बस उनके पास है।

कोई निर्भर प्रकार नहीं हैं, हालांकि मैं संकलक द्वारा स्ट्रिंग की जांच करने से इनकार नहीं करूंगा कि यह एक ईमेल, एक सरणी है, कि यह खाली नहीं है, एक शब्दकोश, जिसमें यह ऐप्पल की है। वैसे, हास्केल में कोई निर्भर प्रकार नहीं हैं।

बीजगणितीय डेटा प्रकार उपलब्ध हैं, और यह एक शांत, लेकिन गणितीय चीज़ को समझना मुश्किल है। सुंदरता यह है कि इसका उपयोग करने के लिए गणितीय रूप से समझने की आवश्यकता नहीं है। उदाहरण के लिए, Int, enum, Optional, Hashable बीजीय प्रकार हैं। और यदि इंट कई भाषाओं में है, और प्रोटोकॉल ऑब्जेक्टिव-सी में है, तो संबंधित मूल्यों के साथ एनम, डिफ़ॉल्ट कार्यान्वयन और साहचर्य प्रकार के प्रोटोकॉल हर जगह से दूर हैं।

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

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

मोनाड्स: एफपी प्रतिमान का हिस्सा नहीं है, लेकिन एक उपकरण (वैकल्पिक)

अक्सर, एफपी और मोनाड एक ही एप्लिकेशन में उपयोग किए जाते हैं। एक समय में, मैंने यह भी सोचा कि भिक्षु कार्यात्मक प्रोग्रामिंग हैं। जब मैंने उन्हें समझा (लेकिन यह सही नहीं है), मैंने कई निष्कर्ष निकाले:

• वे सरल हैं;
• वे सहज हैं;
• उन्हें वैकल्पिक रूप से समझें, यह लागू करने में सक्षम होने के लिए पर्याप्त है;
• आप आसानी से उनके बिना कर सकते हैं।

स्विफ्ट में पहले से ही दो मानक मोनड हैं - वैकल्पिक और परिणाम। दुष्प्रभाव से निपटने के लिए दोनों की आवश्यकता होती है। वैकल्पिक संभव शून्य से बचाता है। परिणाम - विभिन्न असाधारण स्थितियों से।

गैरबराबरी के बिंदु पर लाए गए उदाहरण पर विचार करें। मान लें कि हमारे पास फ़ंक्शंस हैं जो डेटाबेस से और सर्वर से एक पूर्णांक लौटाते हैं। दूसरा शून्य वापस आ सकता है, लेकिन हम उद्देश्य-सी-समय व्यवहार प्राप्त करने के लिए निहित निष्कर्षण का उपयोग करते हैं।

 func getIntFromDB() -> Int func getIntFromServer() -> Int! 

हम वैकल्पिक को अनदेखा करना जारी रखते हैं और इन संख्याओं को योग करने के लिए एक फ़ंक्शन लागू करते हैं।

 func summInts() -> Int! { let intFromDB = getIntFromDB() let intFromServer = getIntFromServer()! let summ = intFromDB + intFromServer return summ } 

हम अंतिम फ़ंक्शन को कॉल करते हैं और परिणाम का उपयोग करते हैं।

 let result = summInts() print(result) 

क्या यह उदाहरण काम करेगा? खैर, यह निश्चित रूप से संकलित करता है, लेकिन क्या हम दुर्घटना को रनटाइम पर प्राप्त करते हैं या नहीं यह किसी के लिए अज्ञात है। यह कोड अच्छा है, यह पूरी तरह से हमारे इरादों को दिखाता है (हमें कुछ दो नंबरों के योग की आवश्यकता है) और इसमें कुछ भी अतिश्योक्तिपूर्ण नहीं है। लेकिन वह खतरनाक है। इसलिए, केवल जूनियर्स और आत्मविश्वास से भरे लोग इस तरह लिखते हैं।

इसे सुरक्षित बनाने के लिए उदाहरण बदलें।

 func getIntFromDB() -> Int func getIntFromServer() -> Int? func summInts() -> Int? { let intFromDB = getIntFromDB() let intFromServer = getIntFromServer() if let intFromServer = intFromServer { let summ = intFromDB + intFromServer return summ } else { return nil } } if let result = summInts() { print(result) } 

यह कोड अच्छा है, यह सुरक्षित है। स्पष्ट निष्कर्षण का उपयोग करते हुए, हमने संभावित नील के खिलाफ बचाव किया। लेकिन यह बोझिल हो गया, और सुरक्षित जाँच के बीच हमारे इरादे को समझ पाना पहले से ही मुश्किल है। हमें अभी भी कुछ दो नंबरों की राशि चाहिए, न कि सुरक्षा जांच।

इस मामले में, वैकल्पिक के पास एक नक्शा विधि है, जो हास्केल से शायद प्रकार से विरासत में मिली है। हम इसे लागू करते हैं, और उदाहरण बदल जाएगा।

 func getIntFromDB() -> Int func getIntFromServer() -> Int? func summInts() -> Int? { let intFromDB = getIntFromDB() let intFromServer = getIntFromServer() return intFromServer.map { x in x + intFromDB } } if let result = summInts() { print(result) } 

या इससे भी अधिक कॉम्पैक्ट।

 func getIntFromDB() -> Int func getintFromServer() -> Int? func summInts() -> Int? { return getintFromServer().map { $0 + getIntFromDB() } } if let result = summInts() { print(result) } 

हमने intFromServer को उस परिणाम में बदलने के लिए मानचित्र का उपयोग किया है जिसे हमें निष्कर्षण के बिना आवश्यकता है।

हमने समन के अंदर चेक से छुटकारा पा लिया, लेकिन इसे शीर्ष स्तर पर छोड़ दिया। यह जानबूझकर किया जाता है, क्योंकि गणना श्रृंखला के अंत में हमें परिणाम की कमी को संसाधित करने के लिए एक विधि का चयन करना चाहिए।

उद्धरण

 if let result = summInts() { print(result) } 

डिफ़ॉल्ट मान का उपयोग करें

 print(result ?? 0) 

या डेटा प्राप्त नहीं होने पर चेतावनी प्रदर्शित करें।

 if let result = summInts() { print(result) } else { print("") } 

अब उदाहरण में कोड बहुत ज्यादा नहीं है, जैसा कि पहले उदाहरण में है, और सुरक्षित है, जैसा कि दूसरे में है।

लेकिन नक्शा हमेशा वैसा काम नहीं करता जैसा कि उसे करना चाहिए

 let a: String? = "7" let b = a.map { Int($0) } type(of: b)//Optional<Optional<Int>> 

यदि हम किसी फ़ंक्शन को मैप करने के लिए पास करते हैं, जिसका परिणाम वैकल्पिक है, तो हमें एक डबल वैकल्पिक मिलता है। लेकिन हमें नील के खिलाफ दोहरे संरक्षण की आवश्यकता नहीं है। एक ही काफी है। फ्लैटपाइप विधि समस्या को हल करने की अनुमति देती है, यह एक अंतर के साथ नक्शे का एक एनालॉग है, यह घोंसले के शिकार गुड़िया को दर्शाती है।

 let a: String? = "7" let b = a.flatMap { Int($0) } type(of: b)//Optional<Int>. 

एक और उदाहरण जहां मानचित्र और फ्लैटपाइप उपयोग करने के लिए बहुत सुविधाजनक नहीं है।

 let a: Int? = 3 let b: Int? = 7 let c = a.map { $0 + b! } 

क्या होगा यदि कोई फ़ंक्शन दो तर्क देता है और वे दोनों वैकल्पिक हैं? बेशक, एफपी का एक समाधान है - यह एक ऐप्लिकेटर फ़ंक्टर और करी है। लेकिन ये उपकरण विशेष ऑपरेटरों का उपयोग किए बिना अजीब लगते हैं जो हमारी भाषा में नहीं हैं, और कस्टम ऑपरेटरों को लिखना बुरा रूप माना जाता है। इसलिए, हम अधिक सहज तरीके से विचार करते हैं: हम एक विशेष फ़ंक्शन लिखते हैं।

 @discardableResult func perform<Result, U, Z>( _ transform: (U, Z) throws -> Result, _ optional1: U?, _ optional2: Z?) rethrows -> Result? { guard let optional1 = optional1, let optional2 = optional2 else { return nil } return try transform(optional1, optional2) } 

यह तर्क के रूप में दो वैकल्पिक मूल्यों और दो तर्कों के साथ एक फ़ंक्शन लेता है। यदि दोनों विकल्पों में मान हैं, तो उनके लिए एक फ़ंक्शन लागू किया जाता है।
अब हम उन्हें तैनात किए बिना कई विकल्पों के साथ काम कर सकते हैं।

 let a: Int? = 3 let b: Int? = 7 let result = perform(+, a, b) 

दूसरे मोनड, रिजल्ट में मैप और फ्लैटपाइप तरीके भी हैं। तो, आप इसके साथ बिल्कुल उसी तरह से काम कर सकते हैं।

 func getIntFromDB() -> Int func getIntFromServer() -> Result<Int, ServerError> func summInts() -> Result<Int, ServerError> { let intFromDB = getIntFromDB() let intFromServer = getIntFromServer() return intFromServer.map { x in x + intFromDB } } if case .success(let result) = summInts() { print(result) } 

दरअसल, यह वही है जो भिक्षुओं को एक साथ लाता है - कंटेनर को हटाने के बिना मूल्य के साथ काम करने की क्षमता। मेरी राय में, यह कोड को संक्षिप्त बनाता है। लेकिन अगर आपको यह पसंद नहीं है, तो केवल स्पष्ट अर्क का उपयोग करें, यह एफपी प्रतिमान का विरोध नहीं करता है।

उदाहरण: गंदे कार्यों की संख्या को कम करना

दुर्भाग्य से, वास्तविक कार्यक्रमों में, वैश्विक राज्य और दुष्प्रभाव हर जगह हैं - नेटवर्क अनुरोध, डेटा स्रोत, यूआई। और केवल शुद्ध कार्यों के साथ तिरस्कृत नहीं किया जा सकता है। लेकिन इसका मतलब यह नहीं है कि एफपी हमारे लिए पूरी तरह से दुर्गम है: हम गंदे कार्यों की संख्या को कम करने की कोशिश कर सकते हैं, जो आमतौर पर कई हैं।

आइए उत्पादन विकास के करीब एक छोटे से उदाहरण को देखें। एक यूआई बनाएँ, विशेष रूप से एक प्रवेश फॉर्म। प्रपत्र की कुछ सीमाएँ हैं:

1) 3 अक्षरों से कम का लॉगिन करें
2) कम से कम 6 अक्षरों का पासवर्ड
3) "लॉगिन" बटन सक्रिय है यदि दोनों फ़ील्ड मान्य हैं।
4) फील्ड फ्रेम का रंग इसकी स्थिति को दर्शाता है, काला - वैध है, लाल है - वैध नहीं है

इन प्रतिबंधों का वर्णन करने वाला कोड इस तरह दिखाई दे सकता है:

किसी भी उपयोगकर्ता इनपुट को संभालना

 @IBAction func textFieldTextDidChange() { // 1.     // 2.   guard let login = loginView.text, let password = passwordView.text else { // 3. - loginButton.isEnabled = false return } let loginIsValid = login.count > constants.loginMinLenght if loginIsValid { // 4. - loginView.layer.borderColor = constants.normalColor } let passwordIsValid = password.count > constants.passwordMinLenght if passwordIsValid { // 5. - passwordView.layer.borderColor = constants.normalColor } // 6. - loginButton.isEnabled = loginIsValid && passwordIsValid } 

लॉग इन पूर्ण प्रक्रिया:

 @IBAction func loginDidEndEdit() { let color: CGColor // 1.     // 2.   if let login = loginView.text, login.count > 3 { color = constants.normalColor } else { color = constants.errorColor } // 3.   loginView.layer.borderColor = color } 

पासवर्ड पूरा होने की प्रक्रिया:

 @IBAction func passwordDidEndEdit() { let color: CGColor // 1.     // 2.   if let password = passwordView.text, password.count > 6 { color = constants.normalColor } else { color = constants.errorColor } // 3. - passwordView.layer.borderColor = color } 

एंटर बटन दबाना:

 @IBAction private func loginPressed() { // 1.     // 2.   guard let login = loginView.text, let password = passwordView.text else { return } auth(login: login, password: password) { [weak self] user, error in if let user = user { /*  */ } else if error is AuthError { guard let `self` = self else { return } // 3. - self.passwordView.layer.borderColor = self.constants.errorColor // 4. - self.loginView.layer.borderColor = self.constants.errorColor } else { /*   */ } } } 

यह कोड सबसे अच्छा नहीं हो सकता है, लेकिन कुल मिलाकर यह अच्छा है और काम करता है। सच है, उसके पास कई समस्याएं हैं:

• 4 स्पष्ट अर्क;
• वैश्विक राज्य पर 4 निर्भरताएं;
• 8 दुष्प्रभाव;
• गैर-स्पष्ट अंत राज्य;
• अधूरा प्रवाह।

मुख्य समस्या यह है कि आप सिर्फ यह नहीं कह सकते कि हमारी स्क्रीन के साथ क्या हो रहा है। एक विधि को देखते हुए, हम देखते हैं कि यह एक वैश्विक स्थिति के साथ क्या करता है, लेकिन हम यह नहीं जानते कि कौन, कहाँ और कब राज्य को स्पर्श करता है। नतीजतन, यह समझने के लिए कि क्या हो रहा है, आपको विचारों के साथ काम के सभी बिंदुओं को खोजने और यह समझने की आवश्यकता है कि क्या प्रभाव होते हैं। यह सब ध्यान में रखना बहुत मुश्किल है।

यदि राज्य को बदलने की प्रक्रिया रैखिक है, तो आप इसे चरण दर चरण अध्ययन कर सकते हैं, जिससे प्रोग्रामर पर संज्ञानात्मक भार कम हो जाएगा।

आइए उदाहरण को बदलने की कोशिश करें, जिससे यह अधिक कार्यात्मक हो।

सबसे पहले, हम एक मॉडल को परिभाषित करते हैं जो स्क्रीन की वर्तमान स्थिति का वर्णन करता है। यह आपको यह जानने की अनुमति देगा कि नौकरी के लिए क्या जानकारी आवश्यक है।

 struct LoginOutputModel { let login: String let password: String var loginIsValid: Bool { return login.count > 3 } var passwordIsValid: Bool { return password.count > 6 } var isValid: Bool { return loginIsValid && passwordIsValid } } 

एक मॉडल जो स्क्रीन पर लागू परिवर्तनों का वर्णन करता है। उसे यह जानने की जरूरत है कि हम क्या बदलेंगे।

 struct LoginInputModel { let loginBorderColor: CGColor? let passwordBorderColor: CGColor? let loginButtonEnable: Bool? let popupErrorMessage: String? } 

इवेंट जो एक नई स्क्रीन स्थिति के लिए नेतृत्व कर सकते हैं। तो हमें पता चल जाएगा कि स्क्रीन किन क्रियाओं को बदलती है।

 enum Event { case textFieldTextDidChange case loginDidEndEdit case passwordDidEndEdit case loginPressed case authFailure(Error) } 

अब हम परिवर्तन की मुख्य विधि का वर्णन करते हैं। यह शुद्ध कार्य, वर्तमान स्थिति के आधार पर, स्क्रीन की एक नई स्थिति एकत्र करता है।

 func makeInputModel( event: Event, outputModel: LoginOutputModel?) -> LoginInputModel { switch event { case .textFieldTextDidChange: let mapValidToColor: (Bool) -> CGColor? = { $0 ? normalColor : nil } return LoginInputModel( loginBorderColor: outputModel .map { $0.loginIsValid } .flatMap(mapValidToColor), passwordBorderColor: outputModel .map { $0.passwordIsValid } .flatMap(mapValidToColor), loginButtonEnable: outputModel?.passwordIsValid ) case .loginDidEndEdit: return LoginInputModel(/**/) case .passwordDidEndEdit: return LoginInputModel(/**/) case .loginPressed: return LoginInputModel(/**/) case .authFailure(let error) where error is AuthError: return LoginInputModel(/**/) case .authFailure: return LoginInputModel(/**/) } } 

सबसे महत्वपूर्ण बात यह है कि यह विधि एकमात्र है जिसे एक नए राज्य के निर्माण में संलग्न होने की अनुमति है - और यह साफ है। इसका अध्ययन चरण दर चरण किया जा सकता है। देखें कि घटनाएँ स्क्रीन को बिंदु A से बिंदु B में कैसे बदलती हैं। यदि कुछ टूटता है, तो समस्या बिल्कुल यहाँ है। और यह परीक्षण करना आसान है।

वर्तमान स्थिति प्राप्त करने के लिए एक सहायक संपत्ति जोड़ें, यह एकमात्र तरीका है जो वैश्विक स्थिति पर निर्भर करता है।

 var outputModel: LoginOutputModel? { return perform(LoginOutputModel.init, loginView.text, passwordView.text) } 

स्क्रीन को बदलने के साइड इफेक्ट बनाने के लिए एक और "गंदा" तरीका जोड़ें।

 func updateView(_ event: Event) { let inputModel = makeInputModel(event: event, outputModel: outputModel) if let color = inputModel.loginBorderColor { loginView.layer.borderColor = color } if let color = inputModel.passwordBorderColor { passwordView.layer.borderColor = color } if let isEnable = inputModel.loginButtonEnable { loginButton.isEnabled = isEnable } if let error = inputModel.popupErrorMessage { showPopup(error) } } 

हालाँकि अद्यतन दृश्य विधि साफ़ नहीं है, यह एकमात्र स्थान है जहाँ स्क्रीन गुण बदलते हैं। गणना की श्रृंखला में पहला और अंतिम आइटम। और अगर कुछ गलत हुआ, तो यह वह जगह है जहां ब्रेकपॉइंट होगा।

यह केवल सही स्थानों पर रूपांतरण शुरू करने के लिए बना हुआ है।

 @IBAction func textFieldTextDidChange() { updateView(.textFieldTextDidChange) } @IBAction func loginDidEndEdit() { updateView(.loginDidEndEdit) } @IBAction func passwordDidEndEdit() { updateView(.passwordDidEndEdit) } 

LoginPressed तरीका थोड़ा अनूठा निकला।

 @IBAction private func loginPressed() { updateView(.loginPressed) let completion: (Result<User, Error>) -> Void = { [weak self] result in switch result { case .success(let user): /*  */ case .failure(let error): self?.updateView(.authFailure(error)) } } outputModel.map { auth(login: $0.login, password: $0.password, completion: completion) } } 

तथ्य यह है कि "लॉगिन" बटन पर क्लिक करने से गणना की दो श्रृंखलाएं लॉन्च होती हैं, जो निषिद्ध नहीं है।

निष्कर्ष

एफपी का अध्ययन करने से पहले, मैंने प्रोग्रामिंग प्रतिमानों पर जोर दिया। यह मेरे लिए महत्वपूर्ण था कि कोड OOP का अनुसरण करता है, मुझे स्थिर कार्य या स्टेटलेस ऑब्जेक्ट पसंद नहीं थे, मैंने वैश्विक फ़ंक्शन नहीं लिखे थे।

अब यह मुझे लगता है कि उन सभी चीजों को जिन्हें मैं एक प्रतिमान का हिस्सा मानता था, बल्कि मनमाना है। मुख्य बात एक साफ, समझने योग्य कोड है। इस लक्ष्य को प्राप्त करने के लिए, आप उन सभी चीजों का उपयोग कर सकते हैं जो संभव है: शुद्ध कार्य, कक्षाएं, भिक्षु, वंशानुक्रम, रचना, प्रकार का निष्कर्ष। वे सभी अच्छी तरह से मिलते हैं और कोड को बेहतर बनाते हैं - बस उन्हें जगह पर लागू करें।

विषय पर और क्या पढ़ना है

विकिपीडिया से कार्यात्मक प्रोग्रामिंग की परिभाषा
हास्केल स्टार्टर बुक
उंगलियों पर फंक्शनलर्स, मोनाड्स और ऐप्लिकेटिव फ़ंक्शंस की व्याख्या
शायद का उपयोग करने के लिए प्रथाओं पर हास्केल पुस्तक (वैकल्पिक)
स्विफ्ट की कार्यात्मक प्रकृति पर पुस्तक
एक विकी से बीजीय डेटा प्रकारों को परिभाषित करना
बीजीय डेटा प्रकारों पर एक लेख
बीजीय डेटा प्रकारों पर एक और लेख
स्विफ्ट पर कार्यात्मक प्रोग्रामिंग पर यैंडेक्स की रिपोर्ट
स्विफ्ट पर प्रिल्यूड स्टैंडर्ड लाइब्रेरी (हास्केल) को लागू करना
स्विफ्ट पर कार्यात्मक उपकरण के साथ पुस्तकालय
एक और पुस्तकालय
और एक और