Swift - Combine multiple discount types - swift

Question

so I've been playing around with protocol witness types, which are in essence concrete implementations of protocols. Say we have a protocol which discounts an item, returning a double.
Instead of this:
protocol Discountable {
func discount() -> Double
}
One does this:
struct Discounting<A> {
let discount: (A) -> Double
}
And, instead of conforming once a type to the Discountable protocol like this:
extension Double: Discountable {
func discount() -> Double {
return self * 0.9
}
}
One can offer multiple concrete implementations for a type:
extension Discounting where A == Double {
static let tenPercentOff = Self { amount in
amount * 0.9
}
static let fiveDollarsOff = Self { amount in
amount - 5
}
}
However, I was wondering how one could combine multiple of these discounts. Here's my initial sketch:
static func combine(_ discounts: [Discounting<A>]) -> Discounting<A> {
Discounting { (amount: A) -> Double in
return discounts.reduce(0.0) { current, discount in
// ??
}
}
}
However, I'm not sure what to put inside the reduce closure.
How can I combine multiple of these Discounting types into one?

Answer 1

With this design, you cannot compose a list of Discounting<A>s for an arbitrary A.
A Discounting<A> represents a way to compute the price after a discount, given an A object. Note that this is a function of A, not a function of price. From the linked article, this type parameter A seems to represent the thing to which you are discounting.
So basically, the information that a [Discounting<A>] contains is a list of functions that, given a thing A, can give you the discounted price for them. As you can see, there is no room for "applying another discount". All you get after applying the first discount is the discounted price, but Discounting represents discounts on things, not prices. You need a discounted A object to apply the second discount.
If you had a Discounting<Double> however, composition is possible,
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)) }
}
To solve the problem for the general case, Discounting<A> could be redesigned as returning a discounted version of the input:
struct Discounting<A> {
let discount: (A) -> A
}
// This is the "protocol witness" version of:
//
// protocol Discountable {
// func discount() -> Self
// }
This way, you can also compose them with the same code that composes Discounting<Double>s that I showed above:
func combine<T>(_ discounts: [Discounting<T>]) -> Discounting<T> {
Discounting(discount: discounts.reduce({ $0 }, { compose($0, $1.discount) }))
}
Example usage:
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)))