Swift泛型场景下如何适配Decimal与Double的类型转换及函数调用？

问题根源在于SignedNumeric约束过于宽泛，无法保证类型可转换为NSNumber；同时拆分函数后，泛型上下文里编译器无法推断T的具体类型，导致找不到匹配的mylog2实现。以下是几种可行的解决方式：

方案一：自定义协议+类型扩展（推荐） #

通过自定义协议约束类型的转换能力，同时继承SignedNumeric保证数值运算支持，让Decimal和Double分别实现转换逻辑：

// 定义协议，要求类型支持转Double并具备数值运算能力
protocol NumericLoggable: SignedNumeric {
    func toDouble() -> Double
}

// Double直接返回自身
extension Double: NumericLoggable {
    func toDouble() -> Double {
        return self
    }
}

// Decimal转换为Double（注意：此转换可能丢失精度）
extension Decimal: NumericLoggable {
    func toDouble() -> Double {
        return Double(truncating: self as NSNumber)
    }
}

// 简化泛型约束的类型别名
typealias Dtype = NumericLoggable

// 泛版mylog2函数
func mylog2<T: Dtype>(_ x: T) -> Double {
    return log2(x.toDouble())
}

// 泛型计算函数，可正常调用mylog2
func myExample<T: Dtype>(_ a: T, _ b: T) -> Double {
    let c: T = (a + b) * (b - a)
    // 其他数值计算逻辑
    return mylog2(c)
}

方案二：直接给类型扩展log2方法 #

更简洁的方式是为Decimal和Double直接扩展log2方法，通过协议统一泛型约束：

// 定义协议，要求类型实现log2方法
protocol LoggableNumeric: SignedNumeric {
    func log2() -> Double
}

// Double封装系统log2方法
extension Double: LoggableNumeric {
    func log2() -> Double {
        return Foundation.log2(self)
    }
}

// Decimal转换后调用log2
extension Decimal: LoggableNumeric {
    func log2() -> Double {
        return Foundation.log2(Double(truncating: self as NSNumber))
    }
}

typealias Dtype = LoggableNumeric

// 泛型函数直接调用类型自身的log2方法
func myExample<T: Dtype>(_ a: T, _ b: T) -> Double {
    let c: T = (a + b) * (b - a)
    // 其他数值计算逻辑
    return c.log2()
}

方案三：泛型where子句+类型转换 #

如果不想新增协议，可通过where子句定义具体类型的mylog2实现，在泛型函数中通过类型转换匹配：

typealias Dtype = SignedNumeric

// Double专用mylog2
func mylog2(_ x: Double) -> Double {
    return log2(x)
}

// Decimal专用mylog2
func mylog2(_ x: Decimal) -> Double {
    return log2(Double(truncating: x as NSNumber))
}

// 泛型函数中通过类型转换匹配具体实现
func myExample<T: Dtype>(_ a: T, _ b: T) -> Double {
    let c: T = (a + b) * (b - a)
    
    if let doubleVal = c as? Double {
        return mylog2(doubleVal)
    } else if let decimalVal = c as? Decimal {
        return mylog2(decimalVal)
    }
    
    fatalError("不支持的数值类型：\(T.self)")
}

注意事项 #

• Decimal转Double会丢失精度，因为Decimal是高精度十进制类型，Double是二进制浮点数，需根据业务场景评估是否接受此损失。
• 后续新增数值类型时，只需让类型遵守自定义协议并实现对应逻辑即可扩展支持。

内容的提问来源于stack exchange，提问作者nilgirian