3

我正在尝试为 Lerp-able (linear-interpolatable) 的类型创建一个协议。我声明它的方式与Equatable定义方式类似：

protocol Lerpable {
    func lerp(from: Self, to: Self, alpha: Double) -> Self
}

不幸的是，当我尝试实现Lerpablefor时Double：

func lerp(from: Double, to: Double, alpha: Double) -> Double {
    return from + alpha * (to - from)
}
extension Double: Lerpable {}

我收到一个错误：Type 'Double' does not conform to protocol 'Lerpable'。

我认为这很简单，但也许我只是不明白 Equatable 是如何工作的。或者它是 Swift 中的一个特例？有什么想法吗？

更新：正确答案如下，这是代码的最终版本，供其他人参考：

protocol Lerpable {
    func lerp(to: Self, alpha: Double) -> Self
}

extension Double: Lerpable {
    func lerp(to: Double, alpha: Double) -> Double {
        return self + alpha * (to - self)
    }
}

func lerp<T: Lerpable>(from: T, to: T, alpha: Double) -> T {
    return from.lerp(to, alpha: alpha)
}

我添加了全局lerp函数，所以我仍然可以将其称为
lerp(foo, bar, alpha: 0.5)
而不是
foo.lerp(bar, alpha: 0.5)

4

2 回答 2

5

要解决您的问题，您需要将lerp函数放在您的extension中，如下所示：

extension Double: Lerpable {
    func lerp(from: Double, to: Double, alpha: Double) -> Double {
        return from + alpha * (to - from)
    }
}

如果你看看Equatable protocol：

protocol Equatable {
    func == (lhs: Self, rhs: Self) -> Bool
}

您在类型之外声明其方法（==特别是）的原因extension是因为Equatable希望您重载运算符，并且必须在全局范围内声明运算符。这是一个澄清的例子：

protocol MyProtocol {
    func *** (lhs: Self, rhs: Self) -> Self
}

现在Int采用协议：

extension Int : MyProtocol {}

infix operator *** {}
func *** (lhs: Int, rhs: Int) -> Int {
    return lhs * rhs
}
于 2015-04-28T22:48:58.037 回答
0

您可以通过为进度值“t”添加类型别名来进一步抽象实现

public protocol Lerpable {
    typealias LerpProgressType
    func lerpTo(value: Self, t: LerpProgressType) -> Self
}
public func lerp<T:Lerpable>(from: T, _ to: T, _ t: T.LerpProgressType) -> T {
    return from.lerpTo(to, t: t)
}

// implementations
extension Double : Lerpable {
    public typealias LerpProgressType = Double
    public func lerpTo(value: Double, t: Double) -> Double {
        return (1.0 - t) * self + t * value
    }
}
extension Float : Lerpable {
    public typealias LerpProgressType = Float
    public func lerpTo(value: Float, t: Float) -> Float {
        return (1.0 - t) * self + t * value
    }
}
extension CGFloat : Lerpable {
    public typealias LerpProgressType = CGFloat
    public func lerpTo(value: CGFloat, t: CGFloat) -> CGFloat {
        return (1.0 - t) * self + t * value
    }
}

您现在还可以扩展各种结构（例如 CGPoint、CGSize、CGRect、CATransform3D 等）：

extension CGPoint : Lerpable {
    public typealias LerpProgressType = CGFloat
    public func lerpTo(value: CGPoint, t: CGFloat) -> CGPoint {
        return
            CGPoint(
                x: x.lerpTo(value.x, t),
                y: y.lerpTo(value.y, t)
            )
    }
}
extension CLLocationCoordinate2D : LinearInterpolation {
    public typealias LerpProgressType = CLLocationDegrees
    public func lerpTo(value: CLLocationCoordinate2D, t: CLLocationDegrees) -> CLLocationCoordinate2D {
        return
            CLLocationCoordinate2D(
                latitude:  latitude.lerpTo(value.latitude, t),
                longitude: longitude.lerpTo(value.longitude, t)
            )
    }
}

在通用结构中实现线性插值：

public struct ValueRange<T> {
    public var start:T
    public var end:T
}

extension ValueRange where T:Lerpable {
    public func lerp(t: T.LerpProgressType) -> T {
        return start.lerpTo(end, t: t)
    }
}
于 2016-02-22T19:45:34.490 回答