स्विफ्ट में, टी + टी

Question

को समझने वाले प्रकारों के लिए सामान्य रूप से फ़ंक्शन को सीमित करने के लिए, मैं एक सामान्य कार्य करना चाहता हूं जो प्लस ऑपरेटर का उपयोग दो मानों पर कर सकता है।

class funccalc { 
    func doAdd<T>(x:T,y:T) -> T { 
     return x + y 
    } 
} 
let a = funccalc() 
println(a.doAdd(1, y: 4)) 
println(a.doAdd(23.54, y:200)) 

मैं return x + y

मेरी केवल यह उत्तर में सुझाव का पालन करने के लिए विकल्प है पर कोई त्रुटि मिलती है: https://stackoverflow.com/a/24047239/67566, और Int के रूप में अपने खुद के प्रोटोकॉल बना सकते हैं और String ऑपरेटर को परिभाषित करेंगे?

Answer 1

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

आप "addable" प्रोटोकॉल का उपयोग नहीं कर सकते क्योंकि स्विफ्ट में कोई भी नहीं है। स्विफ्ट लाइब्रेरी वास्तव में प्रत्येक वैध अतिरिक्त संचालन के लिए एक समारोह + बनाता है। इंट जैसे कुछ पर कमांड-क्लिक करें, यह देखने के लिए कि इन सभी को परिभाषित किया गया है। यह कुछ इस तरह दिखेगा:

//.... 
func +(lhs: Int8, rhs: Int8) -> Int8 
func +(lhs: UInt16, rhs: UInt16) -> UInt16 
func +(lhs: Int16, rhs: Int16) -> Int16 
func +(lhs: UInt32, rhs: UInt32) -> UInt32 
func +(lhs: Int32, rhs: Int32) -> Int32 
//etc... 

Answer 2

तुम भी अन्य कार्यों के लिए इसी तरह की एक आवश्यकता हो सकती है और उन सब पूर्णांक के लिए लागू करने और बिंदु प्रकार (या अन्य "summable" बातें) चल बड़े पैमाने पर कोड दोहराव का कारण होगा।

एक आंशिक समाधान, विशेष रूप से के लिए +, -, *, /,% IntegerArithmeticType को प्रोटोकॉल अनुरूपता की आवश्यकता होती है:

func example<T: IntegerArithmeticType>(x: T, y: T) -> T { return x + y } 
println(example(40, 2)) // --> 42 

यह चल बिन्दु प्रकार पर लागू नहीं होता क्योंकि वे अतिप्रवाह संचालन परिभाषित को लागू नहीं करते _IntegerArithmeticType प्रोटोकॉल में, जो IntegerArithmeticType से विरासत में आता है।

हालांकि, एक विशिष्ट विश्व स्तर पर परिभाषित ऑपरेटर समारोह अनुरूपता के लिए प्रकार का विस्तार नहीं "के रूप में कष्टप्रद" के रूप में आपको लगता है हो सकता है:

protocol Summable { func +(lhs: Self, rhs: Self) -> Self } 

extension Int: Summable {} 
extension Double: Summable {} 
extension String: Summable {} 
// extension for any other types... you are in full control! 

आप एक बार ऐसा करते हैं, तो सर्वदा आप आप कोड में summable उपयोग कर सकते हैं:

func example<T: Summable>(x: T, y: T) -> T { return x + y } 

println(example("4", "2")) // --> 42 

दरअसल, और @connor ने इंगित किया, यह आपके द्वारा उल्लिखित @ जीन-फिलिपपेलेट के उत्तर के बराबर है।