Swift - 函数式编程

函数式编程并不是一门技术,严格来说算是一种代码规范,函数式编程的核心就是把代码的可复用性提高,减少代码量(我个人觉得没必要复用性太严重,否则会出A CALL B B CALL C,然后C里面又CALL了N个函数,这N个函数在N个类里面还有重名,可读性基本没有,适当的降低代码量即可)

// ((num + 4) * 5 - 10)/2
typealias ONETOONE = (Int) -> Int

func plus(_ v:Int) -> ONETOONE {
    return { $0 + v }
}
func duce(_ v:Int) -> ONETOONE {
    return { $0 - v }
}

func multiply(_ v:Int) -> ONETOONE {
    return { $0 * v }
}

func divide(_ v:Int) -> ONETOONE {
    return { $0 / v }
}

let fn1 = plus(4)
let fn2 = multiply(5)
let fn3 = duce(10)
let fn4 = divide(2)
print(fn4(fn3(fn2(fn1(2)))))

每个函数的具体作用只是流程的一部分,比如说plus其作用就是传入一个预设值返回一个闭包,闭包里面带一个参数4,和一个加法函数,进行循环嵌套就能完成上述运算,但这样过程不明显,也可以进行改写

// ((num + 4) * 5 - 10)/2
typealias ONETOONE = (Int) -> Int

func plus(_ v:Int) -> ONETOONE {
    return { $0 + v }
}
func duce(_ v:Int) -> ONETOONE {
    return { $0 - v }
}

func multiply(_ v:Int) -> ONETOONE {
    return { $0 * v }
}

func divide(_ v:Int) -> ONETOONE {
    return { $0 / v }
}

infix operator -->:AdditionPrecedence
func -->(fn:@escaping ONETOONE,fn1:@escaping ONETOONE) -> ONETOONE
{
    return { fn1(fn($0)) }
}

let fn = plus(4) --> multiply(5) --> duce(10) --> divide(2)
print(fn(4))

比如进行运算符重载,就可以完成这种顺序的结构,外面看起来很直观的能感觉出来是((num + 4) * 5 - 10)/2这样的运算顺序

*********注意点 闭包的返回值必须能作为下次的参数传入

Currying(柯里化)

所谓的currying就是把多参数函数,转化成下面这种单个参数的函数

比如下面这段代码

func compute(_ v:Int,_ v1:Int,_ v2:Int) -> Int
{
        let o = v + v1;
        let c = o * v2;
        return c;
}
print(compute(4, 5, 6))

它的Currying版本就是

typealias ONETOONE = (Int) -> Int
func curring_compute(_ v:Int) -> (Int) -> ONETOONE
{
    return { v1 in
        return {v2 in
            return (v + v1) * v2
        }
    }
}
print(curring_compute(4)(5)(6))

所以柯里化就是把fn(v,v1,v2)这种调用方式转化成 fn(v)(v1)(v2)

函子

像Map,Optional这种能支持map运算的类型,叫函子

单子

懵逼中....