Swift函数式编程

Swift相比于Objective-C的语法来讲更加的酷炫，不过也更加的复杂的难懂，为了将Swift的各种语法能够穿插起来，做一个综合笔记，这里实现一个应用多种Swift特性来实现的小功能。

假设现在有一个零售水果的在线商店，需要频繁的用到不同的重量单位，但是最终服务器都是以kg来计算和存储，所以需要频繁的将其他的重量单位转为kg来做为数据的存储，又需要频繁的将kg转换成其他的重量单位来作为显示。

存储属性和计算属性

这里采用封装为一个结构体的方式实现：

struct Kilogram {
    var kg: Double
    var lb: Double {
        set {
            self.kg = newValue * 0.45359237
        }
        get {
            self.kg * 2.20462262
        }
    }

    init(_ kg: Double) {
        self.kg = kg
    }
    
    init() {
        self.kg = 0
    }
}

上面结构体中，只有kg是存储属性，而lb是计算属性，这样就实现我们上面的需求：实现以kg为基础单位的存储功能，同时实现其他单位的换算。

字面量协议

现在结构体可以通过初始化方法初始化：

var w1 = Kilogram()
var w2 = Kilogram(2)
print(w1.kg, w1.lb) // 0.0 0.0 
print(w2.kg, w2.lb) // 2.0 4.40924524 

为了更方便的直接通过字面量初始化，可以实现实现对应的协议：

struct Kilogram: ExpressibleByFloatLiteral, ExpressibleByIntegerLiteral, ExpressibleByStringLiteral, ExpressibleByNilLiteral {
    var kg: Double
    var lb: Double {
        set {
            self.kg = newValue * 0.45359237
        }
        get {
            self.kg * 2.20462262
        }
    }
    
    init(_ kg: Double) {
        self.kg = kg
    }
    
    init() {
        self.kg = 0
    }
    
    init(floatLiteral value: Double) {
        self.kg = value
    }
    
    init(integerLiteral value: Int) {
        self.kg = Double(value)
    }
    
    init(stringLiteral value: String) {
        self.kg = Double(value) ?? 0
    }
    
    init(nilLiteral: ()) {
        self.kg = 0
    }
}

现在就可以直接通过字面量初始化：

var w1: Kilogram = nil
var w2: Kilogram = "1"
var w3: Kilogram = 2
var w4: Kilogram = 3

print(w1.kg, w2.kg, w3.kg, w4.kg) // 0.0 1.0 2.0 3.0

运算符重载

已知两个Kilogram的实例，求他们的重量和，并得转换为lb是多少：

var w1: Kilogram = 3
var w2: Kilogram = 4

var sum = w1.kg + w2.kg
var w3 = Kilogram(sum)
print(w3.kg, w3.lb)

Swift支持运算符重载，为Kilogram结构体添加以下方法：

    static func + (v1: Kilogram, v2: Kilogram) -> Kilogram {
        Kilogram(v1.kg + v2.kg)
    }
    
    static func - (v1: Kilogram, v2: Kilogram) -> Kilogram {
        Kilogram(v1.kg - v2.kg)
    }
    
    static func * (v1: Kilogram, v2: Kilogram) -> Kilogram {
        Kilogram(v1.kg * v2.kg)
    }
    
    static func / (v1: Kilogram, v2: Kilogram) -> Kilogram {
        Kilogram(v1.kg / v2.kg)

下面计算两个Kilogram实例的和：

var w1: Kilogram = 3
var w2: Kilogram = 4

var w3 = w1 + w2
print(w3.kg, w3.lb) // 7.0 15.432358339999999

配合字面量协议支持复杂的运算：

var w1: Kilogram = 3
var w2: Kilogram = 4
var w3: Kilogram = 2

var w4 = w1 + w2 * w3 - 8 // 3 + 4 * 2 - 8 = 3
print(w4.kg, w4.lb) // 3.0 6.613867859999999

枚举的关联值

Swift的枚举相比Objective-C增加非常多的新特性，关联值就是其中之一，关键值可以将枚举的成员值和其他类型的值关联并存储在一起，同样枚举也支持范型、方法（包括初始化方法）、属性（计算实例属性、计算类型属性、存书类型属性）。

按照零售水果的开发需求，需要封装一个水果类，这个水果类需要以下基本信息：名称和单价，而由于平台称重单位有两种，所以单价即可能是kg也可能是lb，这里假设一种水果有且只有一种重量单位的计价方式。那么这个类按照Objective-C的设计方式，起码需要两个属性来表示单价：

typedef NS_ENUM(NSInteger, FruitPriceType) {
    FruitPriceByKg,
    FruitPriceByLb
};

@interface Fruit: NSObject

@property (nonatomic, assign) double price;
@property (nonatomic, assign) FruitPriceType priceType;

@end

通过Swift枚举类型关联值，只需要一个属性就可以实现：

class Fruit {
    enum Price {
        case kg(Double)
        case lb(Double)
    }
    
    var name: String
    var price: Price
    init(name: String, price: Price) {
        self.name = name
        self.price = price
    }
}

在需要计算总价时，只需要判断枚举的类型，取出对应关联值即可：

var apple = Fruit(name: "", price: .lb(3))
var appleWeight: Kilogram = 10

func originalPrice(_ fruit: Fruit, _ weight: Kilogram) -> Double{
    switch fruit.price {
    case let .kg(kg):
        return kg * weight.kg
    case let .lb(lb):
        return lb * weight.lb
    }
}

var price = originalPrice(apple, appleWeight)
print(price)  // 66.13867859999999

函数式编程

下面开始实现水果的总价计算，当用户选择了一定重量的水果，需要根据重量计算出需要支付的总价，假如计算总价的规则如下：

单价 * 重量 * 折扣率 - 优惠金额

这里假设有如下几个拆分的计算总价的分步方法：

/// 原价 = 单价 * 重量
func originalPrice(_ weight: Kilogram, _ fruit: Fruit) -> Double{
    switch fruit.price {
    case let .kg(kg):
        return kg * weight.kg
    case let .lb(lb):
        return lb * weight.lb
    }
}

/// 折扣价 = 原价 * 折扣率
func discountPrice(_ originPrice: Double, _ rate: Double) -> Double {
    return originPrice * rate
}

/// 最终价 = 折扣价 - 优惠金额
func reductionPrice(_ discountPrice: Double, _ reduction: Double) -> Double {
    return discountPrice - reduction
}

假如当前苹果的单价为3/lb，折扣为0.9，优惠金额固定为3，那么10kg苹果的价格计算如下：

var apple = Fruit(name: "", price: .lb(3))
var appleWeight: Kilogram = 10

var price = reductionPrice(discountPrice(originalPrice(apple, appleWeight), 0.9), 3) // 56.52481073999999

这样的方法调用会嵌套很多层，可读性差，并且很难体现出计算过程。

下面将上面三个分步计算方法分别重写为以下三个方法：

func originalPrice(_ fruit: Fruit) -> (_ weight: Kilogram) -> Double {
    {
        weight in
        switch fruit.price {
        case let .kg(kg):
            return kg * weight.kg
        case let .lb(lb):
            return lb * weight.lb
        }
    }
}

func discountPrice(_ rate: Double) -> (_ originPrice: Double) -> Double {
    {
        originPrice in
        rate * originPrice
    }
}

func reductionPrice(_ reduction: Double) -> (_ discountPrice : Double) -> Double {
    {
        discountPrice in
        discountPrice - reduction
    }
}

将每一个方法都重写为传入一个参数，返回一个需要传入一个参数并且有一个返回值的方法。

以originalPrice方法为例：

func originalPrice(_ weight: Kilogram, _ fruit: Fruit) -> Double{
    switch fruit.price {
    case let .kg(kg):
        return kg * weight.kg
    case let .lb(lb):
        return lb * weight.lb
    }
}

func originalPrice(_ fruit: Fruit) -> (_ weight: Kilogram) -> Double {
    {
        weight in
        switch fruit.price {
        case let .kg(kg):
            return kg * weight.kg
        case let .lb(lb):
            return lb * weight.lb
        }
    }
}

原方法需要传入水果实例和重量两个参数，返回对应的原价。重写后方法改为：传入水果实例，返回一个函数，这个函数传入重量，并且返回原价。这样相当于将一个函数拆分为两步返回，第一步返回一个函数，由第一步返回的函数完成最终的函数功能：

var price = originalPrice(apple, appleWeight) // 66.13867859999999

var fn = originalPrice(apple)
price = fn(appleWeight) // 66.13867859999999

接下来，在创建一个自定义运算符，功能就是将两个函数合并成一个函数：

infix operator >>> : AdditionPrecedence
func >>>(_ f1: @escaping (A) -> B, _ f2: @escaping (B) -> C) -> (A) -> C {
    {
        a in
        f2(f1(a))
    }
}

将上面三个函数的计算过程，合并成一个函数：

var applePriceFuction = originalPrice(apple) >>> discountPrice(0.9) >>> reductionPrice(3)

接下来，计算10kg苹果的重量，只需要一行代码就可以完成：

var price = applePriceFuction(10) // 56.52481073999999

柯里化

上面将三个函数分别重写后的形式，就是函数的柯里化。这里将上面三个函数和自定义运算符函数，分别做语法糖的代码简化：

func originalPrice(_ fruit: Fruit) -> (Kilogram) -> Double {
    {
        switch fruit.price {
        case let .kg(kg):
            return kg * $0.kg
        case let .lb(lb):
            return lb * $0.lb
        }
    }
}

func discountPrice(_ rate: Double) -> (Double) -> Double {{ rate * $0 }}

func reductionPrice(_ reduction: Double) -> (Double) -> Double {{ $0 - reduction }}

infix operator >>> : AdditionPrecedence
func >>>(_ f1: @escaping (A) -> B, _ f2: @escaping (B) -> C) -> (A) -> C { { f2(f1($0)) } }

上面三个函数其实目的都是将一个传入两个参数的函数，柯里化成传入一个参数，返回一个需要一次参数的函数，而函数的实际过程本身就是原函数的执行步骤，唯一不同的就是函数参数类型不同而已。针对这个共性，可以将函数柯里化过程，封装为一个函数：

prefix func ~(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C {
    {
        b in
        {
            a in
            fn(a, b)
        }
    }
}

该方法传入一个有两个参数和一个返回值的函数，A、B、C三个范型为传入参数的两个参数和一个返回值的类型。返回一个新的函数，新的函数有一个参数和一个返回值。新的函数参数类型为原函数第二个参数的类型。新的函数的返回值是一个需要传入一个参数的函数，该函数传入的参数类型为原函数第一个函数的类型，返回值类型为原函数的返回值类型。

这个函数的作用就是：将需要两个A类型、B类型参数，并返回C类型值的原函数Z，转变成另一个函数X。X函数只有一个B类型参数，并且返回一个需要传入A类型参数，并且返回C类型值的函数Y。在函数Y中，将X函数的B类型参数b，和Y函数中的A类型参数a，作为原函数Z的两个参数，调用原函数Z，并且返回C类型的返回结果。

将原来的分步柯里化函数都删除或者注释掉，直接使用柯里化函数来柯里化对应的函数，并将返回的函数直接组合：

var applePriceFuction = (~originalPrice)(apple) >>> (~discountPrice)(0.9) >>> (~reductionPrice)(3)
print(applePriceFuction("5")) // 26.762405369999996
print(applePriceFuction(4.5)) // 23.786164832999997
print(applePriceFuction(10)) // 56.52481073999999