二十二、函数式编程、面向协议式编程

2020-02-26 本文已影响0人爱玩游戏的iOS菜鸟

函数式编程（Functional Prigramming）

函数式编程

函数式编程(Functional Prigramming,简称FP)是一种编程范式，也就是如何编写程序的方法论

主要思想：把计算过程尽量分解成一系列可服用函数的调用
主要特征：函数是"第一等公民"
✅函数与其他数据类型一样的地位，可以赋值给变量，也可以作为函数参数、函数返回值

函数式编程最早出现在LISP语言，绝大部分语言也对函数式编程做了不同程度的支持
函数式编程中几个常用的概念

Higher-Order Function、Function Currying
Functor、Applicative Functor、Monad

参考资料：
函数式编程
 函数式编程

FP实践

假如要实现以下功能: [(num + 3) * 5 - 1] % 10 / 2 这个过程用函数实现应该怎么做？
☝️第一种：传统写法

var num = 1

func add(_ v1: Int, _ v2: Int) -> Int{
    v1 + v2
}

func sub(_ v1: Int, _ v2: Int) -> Int{
    v1 - v2
}

func multiple(_ v1: Int, _ v2: Int) -> Int{
    v1 * v2
}

func divide(_ v1: Int, _ v2: Int) -> Int{
    v1 / v2
}

func mod(_ v1: Int, _ v2: Int) -> Int{
    v1 % v2
}

//不仅嵌套多层 且难以理解
divide(mod(sub(multiple(add(num, 3), 5), 1), 10), 2)

✌️第二种写法：

//函数式写法
func fp_add(_ v:Int) -> ((Int) -> Int){
    {
        $0 + v
    }
}

func fp_sub(_ v:Int) -> ((Int) -> Int){
    {
        $0 - v
    }
}

func fp_multiple(_ v:Int) -> ((Int) -> Int){
    {
        $0 * v
    }
}

func fp_divide(_ v:Int) -> ((Int) -> Int){
    {
        $0 / v
    }
}

func fp_mod(_ v:Int) -> ((Int) -> Int){
    {
        $0 % v
    }
}

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

var fn = fp_add(3)>>>fp_multiple(5)>>>fp_sub(1)>>>fp_mod(1)>>>fp_mod(2)
fn(num)

高阶函数

高阶函数至少满足下列一个条件的函数

接受一个或多个函数作为输入(map,filter,reduce等)
返回一个函数

FB到处是高阶函数

柯里化(Currying)

将一个接受多个参数的函数变换为一系列只接受单个参数的函数

func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
//调用 add(10,20) 顺序:10 + 20

func add(_ v: Int) -> (Int) -> Int { { $0 + v } }
//调用 add(20)(10) 顺序:先创建一个 X + 20 的函数 然后传10

Tip：Array、Optional的map方法接收的参数就是一个柯里化函数

三个数相加函数的Curring如下：

//传统的
func add2(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 }

//柯⾥化
//v3 == 30
func add2(_ v3: Int) -> (Int) -> (Int) -> (Int) {
    //v2 == 20
    return { v2 in
        //v1 == 10
        return { v1 in
            return v3 + v2 + v1
        }
    }
}
add2(30)(20)(10) //10 + 20 + 30 = 60

将函数柯里化

//方法1：定义函数将原函数传入，内部柯里化
func add1(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
func add2(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 }

func currying<A, B, C>(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C {
    { b in { a in fn(a, b) } }
}
func currying<A, B, C, D>(_ fn: @escaping (A, B, C) -> D) -> (C) -> (B) -> (A) -> D {
    { c in { b in { a in fn(a, b, c) } } }
}

//传入一个函数，将函数柯里化
currying(add1)(20)(10) //add1(10,20) 10 + 20 = 30  20传给b，10传给a
currying(add2)(30)(20)(10) //add2(10,20,30) 10 + 20 + 30 = 60  30传给c，20传给b，10传给a

//自定义运算符
func add(_ v1: Int, _ v2: Int, v3: Int) -> Int{
    v1 + v2 + v3
}

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

(~add)(30)(20)(10)

再次回顾上面的例子(加减乘除):

func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
func sub(_ v1: Int, _ v2: Int) -> Int { v1 - v2 }
func multiple(_ v1: Int, _ v2: Int) -> Int { v1 * v2 }
func divide(_ v1: Int, _ v2: Int) -> Int { v1 / v2 }
func mod(_ v1: Int, _ v2: Int) -> Int { v1 % v2 }

//重载~运算符，将函数柯⾥化
prefix func ~<A, B, C>(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C {
    { b in { a in fn(a, b) } }
}

//⾃定义>>>运算符
infix operator >>> : AdditionPrecedence
func >>><A, B, C>(_ f1: @escaping (A) -> B,
                  _ f2: @escaping (B) -> C) -> (A) -> C {
    { f2(f1($0)) }
}

var num = 1
var fn = (~add)(3) >>> (~multiple)(5) >>> (~sub)(1) >>> (~mod)(10) >>> (~divide)(2)
fn(num) //[(num + 3) * 5 - 1] % 10 / 2

函子(Functor)

我们先看下面这个函数：

func map<T>(_ fn: (Inner) -> T) -> Type<T>

支持如上map运算的类型才能称为函子：

map运算要支持泛型
要求接收一个函数，这个函数把Type内部存放的数据当作参数传进去，返回一个T
返回的也是同一种Type<T>类型

因此Array、Optional也支持如上的运算即为函子

// Array<Element>
public func map<T>(_ transform: (Element) -> T) -> Array<T>
// Optional<Wrapped>
public func map<U>(_ transform: (Wrapped) -> U) -> Optional<U>

如何去理解函子：

如上该函子，函子里面包装的是2，对这个函子做+3的操作

函子解包取出里面的2，再将2做+3的操作，得到5，最后再将5又放到盒子里面，形成一个新的函子

如果这个函子是可选类型，那么map就不会调用，那么+3操作就不会执行，如下图

Optional类型

如果是数组，里面存放的是2 4 6，先将2 4 6取出来分别做相应的操作，最后操作的结果再包装成数组

Array类型

适用函子

对任意一个函子F，如果能支持以下运算，该函子就是一个适用函子

func pure<A>(_ value: A) -> F<A> //可以理解为，随便给⼀个值就能返回⾃⼰类型的泛型
func <*><A, B>(fn: F<(A) -> B>, value: F<A>) -> F<B> //可以理解为，给⼀个泛型F<A>和⼀个泛型函数fn，最后返回⼀个泛型B

Optional是适用函子

func pure<A>(_ value: A) -> A? { value } //满足了上面第一个条件

infix operator <*> : AdditionPrecedence

func <*><A, B>(fn: ((A) -> B)?, value: A?) -> B? { //满足了上面第二个条件
    guard let f = fn, let v = value else { return nil }
    return f(v)
}

//调用
var value: Int? = 10
var fn: ((Int) -> Int)? = { $0 * 2}
print(fn <*> value as Any) //Optional(20)

如何去理解适用函子：

将需要计算的操作也进行包装

适用函子

Array是适用函子

func pure<A>(_ value: A) -> [A] { [value] }

infix operator <*> : AdditionPrecedence

func <*><A, B>(fn: [(A) -> B], value: [A]) -> [B] {
    var arr: [B] = []
    if fn.count == value.count {
        for i in fn.startIndex..<fn.endIndex {
            arr.append(fn[i](value[I]))
        }
    }
    return arr
}

//调用
print(pure(10)) // [10]

var arr = [{ $0 * 2}, { $0 + 10 }, { $0 - 5 }] <*> [1, 2, 3]
print(arr) // [2, 12, -2]

单子（Monad）

对任意一个类型F，如果能支持以下运算，那么就可以称为是一个单子（Monad）

func pure<A>(_ value: A) -> F<A>
func flatMap<A, B>(_ value: F<A>, _ fn: (A) -> F<B>) -> F<B>

很显然，Array、Optional都是单子

面向协议式编程(Protocol Oriented Programming)

面向协议编程

面向协议编程（Protocol Oriented Programming，简称POP），是Swift的一种编程范式
Swift也是一门面向对象的编程语言（Object Oriented Programming，简称OOP）
在Swift开发中，OOP和POP是相辅相成的，任何一方并不能取代另一方

回顾OOP

OOP的三大特性：封装、继承、多态

继承的经典使用场合：
当多个类（比如A、B、C类）具有很多共性时，可以将这些共性抽取到一个父类中（比如D类），最后A、B、C类继承D类

继承

但是OOP也存在一些不足：如何将 BVC、DVC 的公共方法 run 抽取出来？

如何基于OOP的解决方案？

解决方案：

将run方法放到另一个对象A中，然后BVC、DVC拥有对象A属性

缺点：多了一些额外的依赖关系

将run方法增加到UIViewController分类中

缺点：UIViewController会越来越臃肿，而且会影响它的其他所有子类

将run方法抽取到新的父类，采用多继承？（OC无法做到，C++支持多继承）

缺点：会增加程序设计复杂度，产生菱形继承等问题，需要开发者额外解决

POP解决方案

protocol Runnable {
    func run()
}

extension Runnable {
    func run() {
        print("run")
    }
}

class BVC: UIViewController, Runnable {}
class DVC: UITableViewController, Runnable {}

POP的注意点

优先考虑创建协议，而不是父类(基类)
优先考虑值类型（struct、enum），而不是引用类型（class）
巧用协议的扩展功能
不要为了面向协议而使用协议

利用协议实现前缀效果

值类型

//创建结构体
struct ZQ<Base> {
    let base: Base //Base是传⼊的类型
    init(_ base: Base) { //base是传⼊的类型的值
        self.base = base
    }
}

//创建协议，并给协议扩展类型和实例计算属性
protocol ZQCompatible {}
extension ZQCompatible {
    static var ll: ZQ<Self>.Type { //获取ZQ<Base>类型属性
        get { ZQ<Self>.self }
        set {}
    }
    
    var ll: ZQ<Self> {
    get { ZQ(self) } //获取ZQ<Base>实例属性
    set {}
    }
}

extension String: ZQCompatible {}
extension NSString: ZQCompatible {}
extension ZQ where Base: ExpressibleByStringLiteral { //遵守这个协议的不是String就是NSString
    func numberCount() -> Int {
        let string = base as! String
        var count = 0
        for c in string where ("0"..."9").contains(c) {
            count += 1
        }
        return count
    }
    static func read(){
        print("read")
    }
}

//调用
var s1: String = "34DGF443454"
var s2: NSString = "34DGF443454"
var s3: NSMutableString = "34DGF443454"

//类型方法
String.ll.read()//输出：read

print(s1.ll.numberCount())//输出：8
print(s2.ll.numberCount())//输出：8
print(s3.ll.numberCount())//输出：8

引用类型

class Person {}
class Student: Person {}

//让Person遵守这个协议，并且给ZQ前缀扩充方法
extension Person: ZQCompatible {}
extension ZQ where Base: Person {
    func run() {}
    static func test() {}
}

Person.ll.test()
Student.ll.test()

let p = Person()
p.ll.run()

let s = Student()
s.ll.run()

利用协议实现类型判断

传入的是数组实例:

func isArray(_ value: Any) -> Bool { value is [Any] }
isArray( [1, 2] ) //true
isArray( ["1", 2] ) //true
isArray( NSArray() ) //true
isArray( NSMutableArray() ) //true

传入的是数组类型

protocol ArrayType {}
extension Array: ArrayType {}
extension NSArray: ArrayType {}

func isArrayType(_ type: Any.Type) -> Bool { type is ArrayType.Type }
isArrayType([Int].self) //true
isArrayType([Any].self) //true
isArrayType(NSArray.self) //true
isArrayType(NSMutableArray.self) //true

判断某个类型是否遵守某个协议：
类型.self 即为 ArryType.Type
[Int].self 即为 ArryType.Type

二十二、函数式编程、面向协议式编程

函数式编程（Functional Prigramming）

函数式编程

FP实践

高阶函数

柯里化(Currying)

函子(Functor)

适用函子

单子（Monad）

面向协议式编程(Protocol Oriented Programming)

面向协议编程

回顾OOP

POP解决方案

POP的注意点

利用协议实现前缀效果

利用协议实现类型判断

猜你喜欢

热点阅读