作为to my answer here 的扩展，您可以通过使用“影子方法”以允许Numeric 类型将自己强制为任何其他Numeric 类型（假设目标类型的初始化程序是列为协议要求）。
例如，您可以像这样定义Numeric 协议：
protocol Numeric : Comparable, Equatable {
init(_ v:Float)
init(_ v:Double)
init(_ v:Int)
init(_ v:UInt)
init(_ v:Int8)
init(_ v:UInt8)
init(_ v:Int16)
init(_ v:UInt16)
init(_ v:Int32)
init(_ v:UInt32)
init(_ v:Int64)
init(_ v:UInt64)
init(_ v:CGFloat)
// 'shadow method' that allows instances of Numeric
// to coerce themselves to another Numeric type
func _asOther<T:Numeric>() -> T
}
extension Numeric {
// Default implementation of init(fromNumeric:) simply gets the inputted value
// to coerce itself to the same type as the initialiser is called on
// (the generic parameter T in _asOther() is inferred to be the same type as self)
init<T:Numeric>(fromNumeric numeric: T) { self = numeric._asOther() }
}
然后将类型与Numeric 一致，如下所示：
// Implementations of _asOther() – they simply call the given initialisers listed
// in the protocol requirement (it's required for them to be repeated like this,
// as the compiler won't know which initialiser you're referring to otherwise)
extension Float : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension Double : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension CGFloat : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension Int : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension Int8 : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension Int16 : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension Int32 : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension Int64 : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension UInt : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension UInt8 : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension UInt16 : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension UInt32 : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
extension UInt64 : Numeric {func _asOther<T:Numeric>() -> T { return T(self) }}
示例用法：
class MyClass<T : Numeric> {
var top : T
init(_ top:T) {
self.top = top
}
func topAsCGFloat() -> CGFloat {
return CGFloat(fromNumeric: top)
}
}
let m = MyClass(Int32(42))
let converted = m.topAsCGFloat()
print(type(of:converted), converted) // prints: CGFloat 42.0
这个解决方案可能并不比实现一个方法来切换符合Numeric 的所有类型——但是由于这个解决方案不依赖于运行时类型转换，编译器可能会有更多的优化机会。
它还受益于静态类型检查，这意味着如果不实现将新类型转换为 Numeric 的另一种类型的逻辑，您将无法使新类型符合 Numeric（在您的情况下，您会在运行时崩溃如果类型没有在switch 中处理）。
此外，由于封装，它的扩展更加灵活，因为转换类型的逻辑是在每个符合Numeric 的具体类型中完成的，而不是处理可能情况的单个方法。