Swift - 结合多种折扣类型

Question

所以我一直在玩protocol witness types，它们本质上是协议的具体实现。假设我们有一个协议可以打折一件商品，返回双倍。

而不是这个：

protocol Discountable {
    func discount() -> Double
}

一个人这样做：

struct Discounting<A> {
    let discount: (A) -> Double
}

而且，不是像这样使一个类型符合Discountable 协议：

extension Double: Discountable {
    func discount() -> Double {
        return self * 0.9
    }
}

一个类型可以提供多种具体实现：

extension Discounting where A == Double {
    static let tenPercentOff = Self { amount in
        amount * 0.9
    }
    
    static let fiveDollarsOff = Self { amount in
        amount - 5
    }
}

但是，我想知道如何合并多个这些折扣。这是我最初的草图：

static func combine(_ discounts: [Discounting<A>]) -> Discounting<A> {
    Discounting { (amount: A) -> Double in
        return discounts.reduce(0.0) { current, discount in
            // ??
        }
    }
}

但是，我不确定要在 reduce 闭包中放什么。

如何将这些Discounting 类型中的多个合并为一个？

Answer 1

使用这种设计，您无法为任意A 组成Discounting<A>s 列表。

Discounting<A> 表示在给定A 对象的情况下计算折扣后价格的方法。请注意，这是A 的函数，而不是价格的函数。从链接的文章中，这个类型参数A 似乎代表了您要打折的东西。

所以基本上，[Discounting<A>] 包含的信息是一个功能列表，给定一个东西A，可以为您提供它们的折扣价。如您所见，没有“申请另一个折扣”的空间。应用第一次折扣后，您得到的只是折扣价，但Discounting 表示事物 的折扣，而不是价格。您需要 discounted A 对象来应用第二个折扣。

但是，如果您有 Discounting<Double>，则可以合成，

func combine(_ discounts: [Discounting<Double>]) -> Discounting<Double> {
    Discounting(discount: discounts.reduce({ $0 }, { compose($0, $1.discount) }))
}

func compose<T, U, V>(_ f1: @escaping (T) -> U, _ f2: @escaping (U) -> V) -> ((T) -> V) {
    { f2(f1($0)) }
}

为了解决一般情况下的问题，Discounting<A> 可以重新设计为返回输入的折扣版本：

struct Discounting<A> {
    let discount: (A) -> A
}

// This is the "protocol witness" version of:
//
// protocol Discountable {
//     func discount() -> Self
// }

这样，您也可以使用与我在上面显示的Discounting<Double>s 相同的代码来编写它们：

func combine<T>(_ discounts: [Discounting<T>]) -> Discounting<T> {
    Discounting(discount: discounts.reduce({ $0 }, { compose($0, $1.discount) }))
}

示例用法：

struct Purchase {
    var amount: Double
    var shippingAmount: Double
}

extension Discounting where A == Purchase {
    static let tenPercentOff: Self = .init { purchase in
        Purchase(amount: purchase.amount * 0.9, shippingAmount: purchase.shippingAmount)
    }

    static let tenPercentOffShipping: Self = .init { purchase in
        Purchase(amount: purchase.amount, shippingAmount: purchase.shippingAmount * 0.9)
    }
    
    static let fiveDollarsOff: Self = .init { purchase in
        Purchase(amount: purchase.amount - 5, shippingAmount: purchase.shippingAmount)
    }
}

let combinedDiscounts: Discounting<Purchase> = combine([.tenPercentOff, .fiveDollarsOff, .tenPercentOffShipping])
// Purchase(amount: 85.0, shippingAmount: 90.0)
print(combinedDiscounts.discount(Purchase(amount: 100, shippingAmount: 100)))