स्विफ्ट: एक समारोह पैरामीटर

Question

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

कुछ इस तरह:

private func _addToCurrentTileset(tilesToAdd tiles: SequenceType) 

वहाँ किसी भी तरह से मैं इसे कैसे कर सकते हैं?

यह अपेक्षाकृत सीधा लगता है, लेकिन मैं किसी भी तरह यह समझ नहीं कर सकते हैं। स्विफ्ट toolchain मुझसे कहता है: Protocol 'SequenceType' can only be used as a generic constraint because it has Self or associated type requirements, और मैं एक प्रोटोकॉल है जो SequenceType और इसे से स्व आवश्यकता के अनुरूप होगा बनाने के लिए कैसे पता नहीं है। अब

protocol EnumerableTileSequence: SequenceType { 
    associatedtype GeneratorType = geoBingAnCore.Generator 
    associatedtype SubSequence: SequenceType = EnumerableTileSequence 
} 

अगर कहते हैं कि मैं सरणियों की तरह इस तरह के प्रोटोकॉल परिभाषा अन्य collectionType संस्थाओं के साथ पहले से ही आत्म आवश्यकता को समाप्त कर सकते, तो, सेट के अनुरूप नहीं होगा:

मैं साथ associatedType आवश्यकता नहीं, बल्कि स्वयं को समाप्त कर सकते यह।

संदर्भ: अपने कस्टम दृश्यों प्रगणक प्रकार के सभी उपवर्गों परिभाषित कर रहे हैं के रूप में:

public class Enumerator<T> { 

    public func nextObject() -> T? { 
     RequiresConcreteImplementation() 
    } 
} 

extension Enumerator { 

    public var allObjects: [T] { 
     return Array(self) 
    } 
} 

extension Enumerator: SequenceType { 

    public func generate() -> Generator<T> { 
     return Generator(enumerator: self) 
    } 
} 

public struct Generator<T>: GeneratorType { 

    let enumerator: Enumerator<T> 
    public mutating func next() -> T? { 
     return enumerator.nextObject() 
    } 
} 

Answer 1

संकलक आप जवाब कह रहा है: "प्रोटोकॉल 'अनुक्रम' केवल एक सामान्य बाधा रूप इस्तेमाल किया जा सकता है क्योंकि यह स्वयं या जुड़े प्रकार की आवश्यकताओं है" आप की तरह कुछ के साथ अंत हो सकता है।

इसलिए जेनरिक के साथ ऐसा कर सकते हैं:

private func _addToCurrentTileset<T: Sequence>(tilesToAdd tiles: T) { 
    ... 
} 

यह आपको कोई ठोस प्रकार है कि अपने कार्य में Sequence के अनुरूप में पारित करने के लिए अनुमति देगा। स्विफ्ट ठोस प्रकार का अनुमान लगा होगा, आप खो देते हैं प्रकार की जानकारी के बिना चारों ओर अनुक्रम पारित करने के लिए अनुमति देता है।

आप किसी दिए गए प्रोटोकॉल के अनुक्रम में तत्व के प्रकार को प्रतिबंधित करना चाहते हैं, तो आप कर सकते हैं:

private func _addToCurrentTileset<T: Sequence>(tilesToAdd tiles: T) where T.Element: SomeProtocol { 
    ... 
} 

या एक ठोस प्रकार हैं:

private func _addToCurrentTileset<T: Sequence>(tilesToAdd tiles: T) where T.Element == SomeConcreteType { 
    ... 
} 

आप डॉन हैं ' अनुक्रम के ठोस प्रकार के बारे में परवाह नहीं करते हैं (उन्हें एक साथ मिलाकर और अधिकतर मामलों में उन्हें संग्रहीत करने के लिए उपयोगी), फिर Anton's answer आपको Sequence के प्रकार-मिटा संस्करण के साथ कवर किया गया है।

Answer 2

आप उस के लिए टाइप-रबड़ AnySequence उपयोग कर सकते हैं:

एक प्रकार-मिट अनुक्रम। एक मनमाना अंतर्निहित अनुक्रम, एक ही Element प्रकार होने अंतर्निहित SequenceType की बारीकियों छुपा के लिए

आगे आपरेशनों।

जैसे यदि आप एक आंतरिक संपत्ति के रूप में टाइल्स की दुकान या किसी भी तरह के ढांचे में अपने ठोस प्रकार का उपयोग आप आपत्ति करने की आवश्यकता होगी तो वह जाने का रास्ता होगा।

यदि आपको बस इसे स्टोर करने के लिए अनुक्रम w/o का उपयोग करने में सक्षम होना चाहिए (उदा। बस map), तो आप बस जेनरिक का उपयोग कर सकते हैं (जैसे @ originaluser2 सुझाता है)। जैसे

private func _addToCurrentTileset<S: SequenceType where S.Generator.Element == Tile>(tilesToAdd tiles: S) { 
    let typeErasedSequence = AnySequence(tiles) // Type == AnySequence<Tile> 
    let originalSequence = tiles // Type == whatever type that conforms to SequenceType and has Tile as its Generator.Element 
}