आज मैं आपको एप्पल के नए कॉम्बिनेशन ढांचे में अपना खुद का प्रकाशक बनाने का तरीका बताना चाहूंगा।

और इसलिए, शुरुआत के लिए, हमें संक्षेप में याद करने की आवश्यकता है कि कैसे गठबंधन के मूल भाग एक दूसरे के साथ बातचीत करते हैं, अर्थात् प्रकाशक, सदस्यता, सब्सक्राइबर।

• सब्सक्राइबर प्रकाशक से जुड़ता है
• प्रकाशक सदस्यता सदस्य को भेजता है
• सब्सक्राइबर सब्सक्रिप्शन से एन मान मांगता है
• प्रकाशक एन मान या कम भेजता है
• प्रकाशक एक पूर्ण सिग्नल भेजता है

प्रकाशक

तो चलिए शुरू करते है हमारा पब्लिशर बनाना। Apple प्रलेखन की ओर मुड़ते हुए, हम देखेंगे कि प्रकाशक एक प्रोटोकॉल है।

public protocol Publisher { associatedtype Output associatedtype Failure : Error func receive<S>(subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input } 

जहां आउटपुट इस प्रकाशक द्वारा पारित किए गए मानों का प्रकार है, विफलता विफलता का प्रकार है जिसे त्रुटि प्रोटोकॉल का पालन करना चाहिए।

और प्राप्त समारोह (_: सब्सक्राइबर), जिसे सब्सक्राइबर को सब्सक्राइबर जोड़ने के लिए बुलाया जाएगा सदस्यता (_ :) का उपयोग करके।

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

 struct FibonacciPublisher: Publisher { typealias Output = Int typealias Failure = Never } 

चूंकि अनुक्रम में संख्याएँ होती हैं, इसलिए आउटपुट का प्रकार Int होगा, और विफलता विशेष प्रकार की Never होगी, यह दर्शाता है कि यह प्रकाशक कभी विफल नहीं होगा।

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

 struct FibonacciConfiguration { var count: UInt } 

आइए इस कोड पर एक करीब से नज़र डालें, var count: UInt एक अच्छे विकल्प की तरह दिखता है, लेकिन इसका उपयोग हमें टाइप UInt के मान्य मानों की सीमा तक सीमित करता है, और यह भी स्पष्ट नहीं है कि यदि हम अभी भी असीमित अनुक्रम चाहते हैं, तो क्या इंगित करें।

UInt के बजाय, हम Subscribers.Demand प्रकार का उपयोग करेंगे, जो कि Combine में परिभाषित किया गया है, जहां इसे सब्सक्राइबर से प्रकाशक के माध्यम से प्रकाशक को भेजे जाने वाले प्रकार के रूप में भी वर्णित किया गया है। सरल शब्दों में, यह तत्वों की आवश्यकता को दर्शाता है, सब्सक्राइबर द्वारा कितने तत्वों का अनुरोध किया गया है। असीमित - सीमित नहीं, कोई नहीं - बिल्कुल नहीं, अधिकतम (एन) - एन बार से अधिक नहीं।

  public struct Demand : Equatable, Comparable, Hashable, Codable, CustomStringConvertible { public static let unlimited: Subscribers.Demand public static let none: Subscribers.Demand ///  Demand.max(0) @inlinable public static func max(_ value: Int) -> Subscribers.Demand .... } 

हम गणना के लिए एक नए प्रकार में बदलते फाइबोनैचिऑनफिगरेशन को फिर से लिखते हैं।

 struct FibonacciConfiguration { var count: Subscribers.Demand } 

चलिए हम वापस प्रकाशक के पास जाते हैं और प्राप्त (_: सबस्क्राइबर) पद्धति को लागू करते हैं, जैसा कि हम याद करते हैं, सब्सक्राइबर को प्रकाशक में जोड़ने के लिए इस विधि की आवश्यकता है। और वह सब्सक्रिप्शन के साथ ऐसा करता है, प्रकाशक को सब्सक्रिप्शन बनाना चाहिए और सब्सक्राइबर को सब्सक्रिप्शन ट्रांसफर करना चाहिए।

  func receive<S>(subscriber: S) where S : Subscriber, Failure == S.Failure, Output == S.Input { let subscription = FibonacciSubscription(subscriber: subscriber, configuration: configuration) subscriber.receive(subscription: subscription) } 

यह एक सामान्य फ़ंक्शन है जो सब्सक्राइबर को एक पैरामीटर के रूप में लेता है, और प्रकाशक के आउटपुट मानों को सब्सक्राइबर के इनपुट मूल्यों (आउटपुट == S.Input) से मेल खाना चाहिए, त्रुटियों के लिए समान है। यह प्रकाशक और ग्राहक को "कनेक्ट" करने के लिए आवश्यक है।

फ़ंक्शन में ही, एक फाइबोनैचिस्क्रिप्शन सदस्यता बनाएं, कंस्ट्रक्टर में हम सब्सक्राइबर और कॉन्फ़िगरेशन को स्थानांतरित करते हैं। उसके बाद, सब्सक्रिप्शन सब्सक्राइबर को ट्रांसफर कर दिया जाता है।

हमारा प्रकाशक तैयार है, अंत में हमारे पास है:

 struct FibonacciPublisher: Publisher { typealias Output = Int typealias Failure = Never var configuration: FibonacciConfiguration func receive<S>(subscriber: S) where S : Subscriber, Failure == S.Failure, Output == S.Input { let subscription = FibonacciSubscription(subscriber: subscriber, configuration: configuration) subscriber.receive(subscription: subscription) } } 

जैसा कि आप देख सकते हैं, प्रकाशक के पास फाइबोनैचि अनुक्रम उत्पन्न करने के लिए कोई तर्क नहीं है; सभी तर्क सदस्यता वर्ग - फाइबोनैचिस्क्रिप्शन में होंगे।

जैसा कि आप पहले से ही अनुमान लगा सकते हैं, फाइबोनैचिस्क्रिप्शन क्लास सब्सक्रिप्शन प्रोटोकॉल का पालन करेगा, आइए इस प्रोटोकॉल की परिभाषा देखें।

 public protocol Subscription : Cancellable, CustomCombineIdentifierConvertible { func request(_ demand: Subscribers.Demand) } 

अनुरोध (_: Subscribers.Demand) फ़ंक्शन प्रकाशक को बताता है कि वह ग्राहक को अधिक मूल्य भेज सकता है। यह इस पद्धति में है कि फाइबोनैचि संख्या भेजने का तर्क क्या होगा।
हमें रद्द करने योग्य प्रोटोकॉल का पालन करने और रद्द () फ़ंक्शन को लागू करने की भी आवश्यकता है।

 public protocol Cancellable { func cancel() } 

और बस CustomCombineIdentifierConvertible प्रोटोकॉल का पालन करें और केवल पढ़ने के लिए परिवर्तनीय CombIdentifier को परिभाषित करें।

 public protocol CustomCombineIdentifierConvertible { var combineIdentifier: CombineIdentifier { get } } 

यहाँ एक स्पष्टीकरण है, यदि आप Combine में CustomCombineIdentifierConvertible प्रोटोकॉल की परिभाषा के ठीक नीचे स्क्रॉल करते हैं, तो आप देख सकते हैं कि Combine इस प्रोटोकॉल के लिए एक एक्सटेंशन प्रदान करता है, जिसका रूप है -

 extension CustomCombineIdentifierConvertible where Self : AnyObject { public var combineIdentifier: CombineIdentifier { get } } 

जो हमें बताता है कि वैरिएबल CombIIdentifier की परिभाषा: CombineIdentifier डिफ़ॉल्ट रूप से प्रदान की जाती है यदि इस प्रोटोकॉल का पालन करने वाला प्रकार भी AnyObject प्रोटोकॉल का अनुसरण करता है, अर्थात यदि यह प्रकार एक वर्ग है। फाइबोनैचिस्क्रिप्शन एक वर्ग है, इसलिए हमें डिफ़ॉल्ट चर परिभाषा मिलती है।

अंशदान

और इसलिए हम अपने फाइबोनैचिस्क्रिप्शन को लागू करना शुरू करेंगे।

 private final class FibonacciSubscription<S: Subscriber>: Subscription where S.Input == Int { var subscriber: S? var configuration: FibonacciConfiguration var count: Subscribers.Demand init(subscriber: S?, configuration: FibonacciConfiguration) { self.subscriber = subscriber self.configuration = configuration self.count = configuration.count } ... } 

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

अगला, हम रद्दीकरण प्रोटोकॉल से रद्द () विधि को लागू करते हैं।

 func cancel() { subscriber = nil } 

शून्य पर सब्सक्राइबर को सेट करना सदस्यता के लिए दुर्गम बनाता है।

अब हम फाइबोनैचि संख्या भेजने का कार्यान्वयन शुरू करने के लिए तैयार हैं।
हम अनुरोध विधि को लागू करते हैं (_: Subscribers.Demand)।

 func request(_ demand: Subscribers.Demand) { // 1 guard count > .none else { subscriber?.receive(completion: .finished) return } // 2 count -= .max(1) subscriber?.receive(0) if count == .none { subscriber?.receive(completion: .finished) return } // 3 count -= .max(1) subscriber?.receive(1) if count == .none { subscriber?.receive(completion: .finished) return } // 4 var prev = 0 var current = 1 var temp: Int while true { temp = prev prev = current current += temp subscriber?.receive(current) count -= .max(1) if count == .none { subscriber?.receive(completion: .finished) return } } } 

1) शुरुआत से, हम यह जांचते हैं कि प्रकाशक कितने तत्वों के साथ हमें प्रदान कर सकता है, यदि बिल्कुल नहीं, तो भेजने वाले को पूरा करें और सब्सक्राइबर को एक संकेत भेजें कि नंबर भेजने का काम पूरा हो गया है।
2) यदि कोई आवश्यकता है, तो एक के बाद अनुरोधित संख्याओं की कुल संख्या को कम करें, फाइबोनैचि अनुक्रम के पहले तत्व को सब्सक्राइबर को भेजें, अर्थात् 0 और फिर जांचें कि कितने और तत्व प्रकाशक हमें दे सकते हैं, यदि नहीं, तो सब्सक्राइबर को पूरा करने के लिए एक संकेत भेजें। ।
3) 2 के रूप में एक ही दृष्टिकोण) पैरा, लेकिन केवल फिबोनाची अनुक्रम में दूसरे तत्व के लिए।
4) यदि 2 से अधिक तत्वों की आवश्यकता है, तो हम फाइबोनैचि संख्याओं को खोजने के लिए एक पुनरावृत्त एल्गोरिथ्म को लागू करते हैं, जहां प्रत्येक चरण पर हम अगले नंबर को फाइबोनैचि अनुक्रम से सबस्क्राइबर में स्थानांतरित करेंगे और यह भी जांचेंगे कि प्रकाशक अभी भी कितने तत्व प्रदान कर सकते हैं। यदि प्रकाशक अब नए नंबर प्रदान नहीं करता है, तो सब्सक्राइबर को पूरा होने का संकेत भेजें।

 struct FibonacciConfiguration { var count: Subscribers.Demand } struct FibonacciPublisher: Publisher { typealias Output = Int typealias Failure = Never var configuration: FibonacciConfiguration func receive<S>(subscriber: S) where S : Subscriber, Failure == S.Failure, Output == S.Input { let subscription = FibonacciSubscription(subscriber: subscriber, configuration: configuration) subscriber.receive(subscription: subscription) } } private final class FibonacciSubscription<S: Subscriber>: Subscription where S.Input == Int { var subscriber: S? var configuration: FibonacciConfiguration var count: Subscribers.Demand init(subscriber: S?, configuration: FibonacciConfiguration) { self.subscriber = subscriber self.configuration = configuration self.count = configuration.count } func cancel() { subscriber = nil } func request(_ demand: Subscribers.Demand) { // 1 guard count > .none else { subscriber?.receive(completion: .finished) return } // 2 count -= .max(1) subscriber?.receive(0) if count == .none { subscriber?.receive(completion: .finished) return } // 3 count -= .max(1) subscriber?.receive(1) if count == .none { subscriber?.receive(completion: .finished) return } // 4 var prev = 0 var current = 1 var temp: Int while true { temp = prev prev = current current += temp subscriber?.receive(current) count -= .max(1) if count == .none { subscriber?.receive(completion: .finished) return } } } } 

पहले परीक्षण

अब हम परीक्षण करते हैं कि हमारे पास क्या है, हमारे पास हमारा प्रकाशक और सदस्यता है, हमारे पास सिब्स्क्राइबर की कमी है, कॉम्बिनेशन बॉक्स से 2 सिब्स्क्राइबर प्रदान करता है, यह सिंक और असाइन है।

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

सिंक हमारे उद्देश्य के लिए अच्छी तरह से अनुकूल है, इस तथ्य पर विशेष ध्यान दिया जाना चाहिए कि यह असीमित संख्या में मूल्यों का अनुरोध करता है।

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

हमारे प्रकाशक का उपयोग करने की सुविधा के लिए, हम इसके निर्माण को प्रोटोकोल प्रोटोकॉल एक्सटेंशन में जोड़ते हैं।

 extension Publishers { private static func fibonacci(configuration: FibonacciConfiguration) -> FibonacciPublisher { FibonacciPublisher(configuration: configuration) } static func fibonacci(count: Subscribers.Demand = .max(6)) -> FibonacciPublisher { FibonacciPublisher(configuration: FibonacciConfiguration(count: count)) } } 

और इसलिए हमारे प्रकाशक की कोशिश करें

 Publishers.fibonacci(count: .max(10)) .sink { value in print(value, terminator: " ") } // print 0 1 1 2 3 5 8 13 21 34 - OK 

और अब सीमा मामले

 Publishers.fibonacci(count: .max(1)) .sink { value in print(value, terminator: " ") } // prinst 0 - OK Publishers.fibonacci(count: .max(2)) .sink { value in print(value, terminator: " ") } // prints 0 1 - OK Publishers.fibonacci(count: .none) .print() //    publisher'a .sink { value in print(value, terminator: " ") } // prints receive finished - OK 

लेकिन अगर आप निर्दिष्ट करें तो क्या होता है।

 Publishers.fibonacci(count: .unlimited) .print() .sink { value in print(value, terminator: " ") } // prints 0 1 1 2 3 5 8 13 21 ...   ,     Int. 

आप .unlimited का उपयोग कैसे कर सकते हैं, लेकिन कई नंबरों को आउटपुट करने में सक्षम हैं? ऐसा करने के लिए, हमें .prefix (_) ऑपरेटर की आवश्यकता होती है, जो संग्रह से .prefix (_) के समान कार्य करता है, अर्थात यह केवल पहले N तत्वों को छोड़ता है।

 Publishers.fibonacci(count: .unlimited) .print() .prefix(5) .sink { _ in } // prints 0 1 1 2 3 cancel   ,       Int. 

क्या समस्या है? शायद .prefix (_) में? आइए फाउंडेशन से मानक अनुक्रम पर थोड़ा प्रयोग करें।

 //   1 2 3 4 5 6 7 8 ... 1... .publisher .print() .prefix(5) .sink { _ in } // prints 1 2 3 4 5 cancel -  

जैसा कि हम देख सकते हैं, उपरोक्त कोड ने सही तरीके से काम किया है, तो समस्या प्रकाशक के हमारे कार्यान्वयन में है।
हम .print () से लॉग को देखते हैं और देखते हैं कि N रिक्वेस्ट के बाद .prefix (_) से, हम अपने फाइबोनैचिस्क्रिप्शन पर कैंसिल () कहते हैं, जहाँ हम सब्सक्राइबर को शून्य पर सेट करते हैं।

  func cancel() { subscriber = nil } 

यदि आप कॉल स्टैक खोलते हैं, तो आप देख सकते हैं कि ग्राहक से कॉल के दौरान रिक्वेस्ट () को रिक्वेस्ट कहा जाता है (_ :), .Receive (_)। जिससे हम यह निष्कर्ष निकाल सकते हैं कि अनुरोध के समय कुछ बिंदु पर (_ :) ग्राहक शून्य हो सकते हैं और फिर हमें नए नंबर बनाने के काम को रोकने की आवश्यकता है। इस शर्त को हमारे कोड में जोड़ें।

  func request(_ demand: Subscribers.Demand) { // 1 guard count > .none else { subscriber?.receive(completion: .finished) return } // 2 count -= .max(1) subscriber?.receive(0) guard let _ = subscriber else { return } // new if count == .none { subscriber?.receive(completion: .finished) return } // 3 count -= .max(1) subscriber?.receive(1) guard let _ = subscriber else { return } // new if count == .none { subscriber?.receive(completion: .finished) return } // 4 var prev = 0 var current = 1 var temp: Int while let subscriber = subscriber { // new temp = prev prev = current current += temp subscriber.receive(current) count -= .max(1) if count == .none { subscriber.receive(completion: .finished) return } } } 

अब हमारे परीक्षण कोड को चलाएं।

 Publishers.fibonacci(count: .unlimited) .print() .prefix(5) .sink { _ in } // prints 0 1 1 2 3 cancel -  

अपेक्षित व्यवहार मिला।

ग्राहक

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

 class FibonacciSubscriber: Subscriber { typealias Input = Int typealias Failure = Never var limit: Subscribers.Demand init(limit: Subscribers.Demand) { self.limit = limit } func receive(subscription: Subscription) { subscription.request(limit) } func receive(_ input: Input) -> Subscribers.Demand { .none } func receive(completion: Subscribers.Completion<Failure>) { print("Subscriber's completion: \(completion)") } } 

और इसलिए हमारे फाइबोनैचिस्क्राइबर के पास एक सीमा संपत्ति है, जो यह निर्धारित करती है कि यह सब्सक्राइबर कितने तत्वों को प्राप्त करना चाहता है। और यह प्राप्त (_: सदस्यता) विधि में किया जाता है, जहां हम सदस्यता को बताते हैं कि हमें कितने तत्वों की आवश्यकता है। यह भी प्राप्त करने के लायक है (_: इनपुट) -> सबस्क्राइबर्स। डिमांड फ़ंक्शन, इस फ़ंक्शन को एक नया मान प्राप्त होने पर कहा जाता है, जैसा कि रिटर्न वैल्यू हम इंगित करते हैं कि हम कितने अतिरिक्त तत्वों को प्राप्त करना चाहते हैं: .none - बिल्कुल नहीं ।max (N) N मोहरे। , कुल में, प्राप्त तत्वों की कुल संख्या प्राप्त (_: सदस्यता) में भेजे गए सदस्यता के मूल्य के योग के बराबर होगी और प्राप्त से सभी रिटर्न मान (_: इनपुट) -> Subscribers.Demand।

दूसरा परीक्षण

आइए, फाइबोनैचिस्क्रिप्‍सर का उपयोग करके देखें।

 let subscriber = FibonacciSubscriber(limit: .max(3)) Publishers.fibonacci(count: .max(5)) .print() .subscribe(subscriber) // prints 0 1 1 2 3 -     0 1 1 

जैसा कि हम देखते हैं कि हमारे प्रकाशक ने 3 के बजाय 5 मान भेजे हैं। ऐसा क्यों? चूँकि अनुरोध (_: Subscribers.Demand) का तरीका फाइबोनैचिस्क्रिप्शन की विधि ग्राहक की जरूरतों को ध्यान में नहीं रखती है, तो इसे ठीक करें, इसके लिए हम अनुरोध की गई एक अतिरिक्त संपत्ति जोड़ेंगे, जिसके माध्यम से हम ग्राहक की जरूरतों को ट्रैक करेंगे।

 private final class FibonacciSubscription<S: Subscriber>: Subscription where S.Input == Int { var subscriber: S? var configuration: FibonacciConfiguration var count: Subscribers.Demand var requested: Subscribers.Demand = .none // new init(subscriber: S?, configuration: FibonacciConfiguration) { self.subscriber = subscriber self.configuration = configuration self.count = configuration.count } func cancel() { subscriber = nil } func request(_ demand: Subscribers.Demand) { guard count > .none else { subscriber?.receive(completion: .finished) return } requested += demand // new count -= .max(1) requested -= .max(1) // new requested += subscriber?.receive(0) ?? .none // new guard let _ = subscriber, requested > .none else { return } // new if count == .none { subscriber?.receive(completion: .finished) return } count -= .max(1) requested -= .max(1) // new requested += subscriber?.receive(1) ?? .none // new guard let _ = subscriber, requested > .none else { return } // new if count == .none { subscriber?.receive(completion: .finished) return } var prev = 0 var current = 1 var temp: Int while let subscriber = subscriber, requested > .none { // new temp = prev prev = current current += temp requested += subscriber.receive(current) // new count -= .max(1) requested -= .max(1) // new if count == .none { subscriber.receive(completion: .finished) return } } } } 

तीसरा परीक्षण

 let subscriber = FibonacciSubscriber(limit: .max(3)) Publishers.fibonacci(count: .max(5)) .print() .subscribe(subscriber) // prints 0 1 1 - OK 

प्रकाशक अब सही ढंग से काम कर रहा है।

 import Foundation import Combine struct FibonacciConfiguration { var count: Subscribers.Demand } struct FibonacciPublisher: Publisher { typealias Output = Int typealias Failure = Never var configuration: FibonacciConfiguration func receive<S>(subscriber: S) where S : Subscriber, Failure == S.Failure, Output == S.Input { let subscription = FibonacciSubscription(subscriber: subscriber, configuration: configuration) subscriber.receive(subscription: subscription) } } private final class FibonacciSubscription<S: Subscriber>: Subscription where S.Input == Int { var subscriber: S? var configuration: FibonacciConfiguration var count: Subscribers.Demand var requested: Subscribers.Demand = .none init(subscriber: S?, configuration: FibonacciConfiguration) { self.subscriber = subscriber self.configuration = configuration self.count = configuration.count } func cancel() { subscriber = nil } func request(_ demand: Subscribers.Demand) { guard count > .none else { subscriber?.receive(completion: .finished) return } requested += demand count -= .max(1) requested -= .max(1) requested += subscriber?.receive(0) ?? .none guard let _ = subscriber, requested > .none else { return } if count == .none { subscriber?.receive(completion: .finished) return } count -= .max(1) requested -= .max(1) requested += subscriber?.receive(1) ?? .none guard let _ = subscriber, requested > .none else { return } if count == .none { subscriber?.receive(completion: .finished) return } var prev = 0 var current = 1 var temp: Int while let subscriber = subscriber, requested > .none { temp = prev prev = current current += temp requested += subscriber.receive(current) count -= .max(1) requested -= .max(1) if count == .none { subscriber.receive(completion: .finished) return } } } } extension Publishers { private static func fibonacci(configuration: FibonacciConfiguration) -> FibonacciPublisher { FibonacciPublisher(configuration: configuration) } static func fibonacci(count: Subscribers.Demand = .max(6)) -> FibonacciPublisher { FibonacciPublisher(configuration: FibonacciConfiguration(count: count)) } } class FibonacciSubscriber: Subscriber { typealias Input = Int typealias Failure = Never var limit: Subscribers.Demand init(limit: Subscribers.Demand) { self.limit = limit } func receive(subscription: Subscription) { subscription.request(limit) } func receive(_ input: Input) -> Subscribers.Demand { .none } func receive(completion: Subscribers.Completion<Failure>) { print("Subscriber's completion: \(completion)") } } Publishers.fibonacci(count: .max(4)) .print() .sink { _ in } let subscriber = FibonacciSubscriber(limit: .max(3)) Publishers.fibonacci(count: .max(5)) .print() .subscribe(subscriber) 

परिणाम

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