如何在swift中使用泛型类型处理不同的类型？

Question

我试图写一个类，让我方便地在两个值之间的插值。

class Interpolation 
{ 
    class func interpolate<T>(from: T, to: T, progress: CGFloat) -> T 
    { 
     // Safety 
     assert(progress >= 0 && progress <= 1, "Invalid progress value: \(progress)") 

     if let a = from as? CGFloat, let b = to as? CGFloat 
     { 
     } 
     if let a = from as? CGPoint, let b = to as? CGPoint 
     { 

     } 
     if let from = from as? CGRect, let to = to as? CGRect 
     { 
      var returnRect = CGRect() 
      returnRect.origin.x  = from.origin.x + (to.origin.x-from.origin.x) * progress 
      returnRect.origin.y  = from.origin.y + (to.origin.y-from.origin.y) * progress 
      returnRect.size.width = from.size.width + (to.size.width-from.size.width) * progress 
      returnRect.size.height = from.size.height + (to.size.height-from.size.height) * progress 
      return returnRect // Cannot convert return expression of type 'CGRect' to return type 'T' 
     } 

     return from 
    } 
} 

不幸的是，它给了我在return returnRect错误：无法转换类型的返回式“的CGRect”返回类型“T”。也许我不懂如何使用泛型...我只想有一个函数可以处理各种类型之间的插值，而不是像func interpolate(from: Int, to: Int),func interpolate(from: CGPoint, to: CGPoint)等一堆函数。

Answer 1

的问题是，T是一个通用的占位符 - 意思是说你不能知道T的实际具体类型是从哪里来的 功能。因此，尽管您可以有条件地将from和to转换为CGRect（因此确定T == CGRect），但Swift无法推断此信息，因此当它预计返回T时，禁止尝试返回CGRect。

因此，原油的解决办法是强制转换返回结果返回给T以弥合与类型的系统信息，这种差距：

if let from = from as? CGRect, let to = to as? CGRect { 

    // ... 

    return returnRect as! T 
} 

然而，这种类型转换的是一个真正的表示您正在与类型系统打交道，未利用泛型提供的静态类型，因此不推荐。

更好的解决方案，如@Wongzigii has already said，是使用的协议。例如，如果你定义一个Interpolate协议，因为他显示了他的答案 - 那么你可以使用此协议，以限制你的通用占位符T在interpolate功能：

class Interpolation { 
    class func interpolate<T:Interpolate>(from: T, to: T, progress: CGFloat) -> T { 

     // Safety 
     assert(progress >= 0 && progress <= 1, "Invalid progress value: \(progress)") 

     return T.interpolate(from: from, to: to, progress: progress) 
    } 
} 

这解决了很多你的问题 - 它摒弃了运行时的类型转换，而是使用协议的约束，以调用专门interpolate功能。该协议的约束也防止你通过不在编译时符合Interpolate任何类型，因此也解决了，当你的类型转换失败怎么办的问题。

虽然这样说，我其实蛮喜欢的解决方案，@JoshCaswell suggested in his answer到您的其他问题 - 以重载运营商实现这一功能。和以前的解决方案一样，关键是定义一个协议，该协议封装了您在每种类型上定义的功能，然后将通用功能限制为该协议。

一个简单的实现可能是这样的：

protocol Interpolatable { 
    func +(lhs:Self, rhs:Self) -> Self 
    func -(lhs:Self, rhs:Self) -> Self 
    func *(lhs:Self, rhs:CGFloat) -> Self 
} 

func +(lhs:CGRect, rhs:CGRect) -> CGRect { 
    return CGRect(x: lhs.origin.x+rhs.origin.x, 
        y: lhs.origin.y+rhs.origin.y, 
        width: lhs.size.width+rhs.size.width, 
        height: lhs.size.height+rhs.size.height) 
} 

func -(lhs:CGRect, rhs:CGRect) -> CGRect { 
    return CGRect(x: lhs.origin.x-rhs.origin.x, 
        y: lhs.origin.y-rhs.origin.y, 
        width: lhs.size.width-rhs.size.width, 
        height: lhs.size.height-rhs.size.height) 
} 

func *(lhs:CGRect, rhs:CGFloat) -> CGRect { 
    return CGRect(x: lhs.origin.x*rhs, 
        y: lhs.origin.y*rhs, 
        width: lhs.size.width*rhs, 
        height: lhs.size.height*rhs) 
} 

extension CGRect : Interpolatable {} 
extension CGFloat : Interpolatable {} 

class Interpolation { 
    class func interpolate<T:Interpolatable>(from: T, to: T, progress: CGFloat) -> T { 
     assert(progress >= 0 && progress <= 1, "Invalid progress value: \(progress)") 
     return from + (to - from) * progress 
    } 
} 

Answer 2

这将是很好的如果你使用Protocol来扩展您的通用类型。

protocol Interpolate { 
    associatedtype T 
    static func interpolate(from: T, to: T, progress: CGFloat) -> T 
} 

然后让CGRect扩展符合您的协议：

extension CGRect: Interpolate { 
    typealias T = CGRect 
    static func interpolate(from: T, to: T, progress: CGFloat) -> CGRect.T { 
     var returnRect = CGRect() 
     returnRect.origin.x  = from.origin.x + (to.origin.x-from.origin.x) * progress 
     returnRect.origin.y  = from.origin.y + (to.origin.y-from.origin.y) * progress 
     returnRect.size.width = from.size.width + (to.size.width-from.size.width) * progress 
     returnRect.size.height = from.size.height + (to.size.height-from.size.height) * progress 
     return returnRect 
    } 
} 

var from = CGRect(x: 0, y: 0, width: 1, height: 1) // (0, 0, 1, 1) 
var to = CGRect(x: 1, y: 1, width: 0, height: 0) // (1, 1, 0, 0) 

CGRect.interpolate(from, to: to, progress: 1)  // (1, 1, 0, 0) 

此外，这将使NSString符合协议Interpolate容易，如：

extension NSString: Interpolate { 
    typealias T = NSString 
    static func interpolate(from: T, to: T, progress: CGFloat) -> NSString.T { 
     //... 
     return "" 
    } 
}