Do इंट और डबल स्विफ्ट

Question

में

एक आम माता पिता वर्ग का हिस्सा अगर वहाँ एक सामान्य प्रारंभकर्ता

public required init(_ value : Double) { 
    super.init(value: value, unitType: unit) 
} 

public required init(_ value : Int) { 
    let v = Double(value) 
    super.init(value: v, unitType: unit) 
} 

कुछ तरह के रूप में इन दो initializers लिखने के लिए एक आसान तरीका है मैं सोच रहा हूँ:

public init<T>(_value : T) { 
    let v = Double(T) 
    super.init(value: v, unitType: unit) 
} 

(जो निश्चित रूप से संकलित नहीं करता है)

मैंने इंट और डबल दोनों के कोड को देखा है और किसी भी वास्तविक चीज़ को याद कर रहा हूं जो उन्हें एक साथ जोड़ता है।

Answer 1

स्विफ्ट हैडर पर एक नज़र डालें:

extension String : StringInterpolationConvertible { 
    init(stringInterpolationSegment expr: String) 
    init(stringInterpolationSegment expr: Character) 
    init(stringInterpolationSegment expr: UnicodeScalar) 
    init(stringInterpolationSegment expr: Bool) 
    init(stringInterpolationSegment expr: Float32) 
    init(stringInterpolationSegment expr: Float64) 
    init(stringInterpolationSegment expr: UInt8) 
    init(stringInterpolationSegment expr: Int8) 
    init(stringInterpolationSegment expr: UInt16) 
    init(stringInterpolationSegment expr: Int16) 
    init(stringInterpolationSegment expr: UInt32) 
    init(stringInterpolationSegment expr: Int32) 
    init(stringInterpolationSegment expr: UInt64) 
    init(stringInterpolationSegment expr: Int64) 
    init(stringInterpolationSegment expr: UInt) 
    init(stringInterpolationSegment expr: Int) 
} 

इसी तरह:

func +(lhs: UInt8, rhs: UInt8) -> UInt8 
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 
func +(lhs: UInt64, rhs: UInt64) -> UInt64 
func +(lhs: Int64, rhs: Int64) -> Int64 
func +(lhs: UInt, rhs: UInt) -> UInt 
func +(lhs: Int, rhs: Int) -> Int 
func +(lhs: Float, rhs: Float) -> Float 
func +(lhs: Double, rhs: Double) -> Double 
func +(lhs: Float80, rhs: Float80) -> Float80 

यदि यह सभी उन विभिन्न सांख्यिक प्रकार के लिए एक सामान्य समारोह लिखने के लिए संभव थे, वे निश्चित रूप से यह किया है। तो आपके सवाल का जवाब होना चाहिए नहीं।

(और किसी भी मामले में वे शायद ही, एक माता पिता वर्ग साझा कर सकते हैं के रूप में वे क्लासों नहीं है। वे structs कर रहे हैं।) निश्चित रूप से,

अब , यदि केवल Int और Double प्रश्न में हैं, आप एक सामान्य प्रोटोकॉल को अपनाने के लिए Int और Double का विस्तार कर सकते हैं और उस प्रोटोकॉल को अपेक्षित प्रकार बना सकते हैं ...