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<Double> {
        case kg(Double)
        case lb(Double)
    }
    
    var name: String
    var price: Price<Double>
    init(name: String, price: Price<Double>) {
        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 >>><A, B, C>(_ 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 >>><A, B, C>(_ f1: @escaping (A) -> B, _ f2: @escaping (B) -> C) -> (A) -> C { { f2(f1($0)) } }

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

prefix func ~<A, B, C>(_ 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
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,294评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,493评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,790评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,595评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,718评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,906评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,053评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,797评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,250评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,570评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,711评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,388评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,018评论 3赞 316
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,796评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,023评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,461评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,595评论 2赞 350