Swift - 函数式编程

let num = 1
func add(_ v:Int) -> (Int)->Int {
        
        return {
            $0 + v
        }
        
    }

var fn = add(3)
fn(20)
print(fn(20))

在上面代码中，我们定义了一个函数，该函数接收一个参数，返回一个函数，也算返回一个闭包var fn = add(3)，这里的fn，就是add函数返回值，同时这个返回值也是一个函数，调用这个fn函数，fn(20),相当于就是调用了$0+v，所以得到的结果是23，这有什么好处呢，首先我们确定的一个就是最初的调用add(3)，这里我们传入了3，那么这个三就算是固定了，那么后面所有的fn的调用，都传入了这个3，这个3就是当初传入的那个v，随后传入到了**(Int) -> Int中去了。

示例

var fn = add(3)
fn(20) // 23
fn(100) // 103
fn(97) // 100
fn(80) // 83

相当于fn这个函数，是可以循环利用的

    let num = 1
    func add(_ v:Int) -> (Int)->Int { { $0 + v } }
    func sub(_ v:Int) -> (Int)->Int { { $0 - v  }}
    func multipe(_ v:Int) -> (Int)->Int { { $0 * v } }
    func divide(_ v:Int) -> (Int) -> Int { { $0 / v } }
    func mod(_ v:Int) -> (Int)-> Int { { $0 % v } }

    let fn1 = add(3)
    let fn2 = multipe(5)
    let fn3 = sub(1)
    let fn4 = mod(10)
    let fn5 = divide(2)
    print(fn5(fn4(fn3(fn2(fn1(num)))))) // 4

从调用的方式来看，可读性其实并不是很好print(fn5(fn4(fn3(fn2(fn1(num))))))，尝试一下看看能不能合并起来

func composite(_ f1:@escaping (Int) -> Int,_ f2:@escaping (Int) -> Int) -> (Int) -> Int{
        return {
            f2(f1($0)) // $0其实就是外界传进来的num值
            // f1($0)其实就是add(3)(num)
            // f2同理可推
      }
}

let fn = composite(add(3), multipe(5))
fn(num)
这里的函数fn(num)调用，其实就是完成了(num+3)*5的操作

高阶函数

截屏2022-03-09 下午12.08.13.png

柯里化（Currying）

将一个接收多参数的函数变换为一系列直接收单个参数的函数 截屏2022-03-09 下午12.13.00.png

func add1(_ v1:int,_ v2:int) -> Int {
      //   如何对这个函数进行柯里化
}

func add1(_ v:int) -> (Int) - Int {
  return { a in
            v + a
      }
}
或者这么写
func add1(_ v:Int) -> (Int)->Int {

   return {
            $0 + v
        }
    }

进阶

func add2(_ v1:Int,_ v2:Int,_ v3:Int) -> Int {}
如何对这个函数进行柯里化

func add2(_ v:Int) -> (Int) -> (Int) -> Int {
 // 如何对这个函数进行柯里化
}

func add2(_ v:Int) -> (Int) -> (Int) -> Int {
        return { a in
            return { b in
                
                v + a + b
            }
        }
    }

print(add2(10)(20)(30)) // 60

解析一下，add2接收一个参数，返回一个函数，而返回的这个函数中，接收一个参数，也返回一个函数，在第一个return中，其实return的是((Int) -> (Int) -> Int)这个函数，第二个return的，才是最后返回的函数(Int)->Int

    func add(_ v1:Int,_ v2:Int) -> Int { v1+v2 }
    func sub(_ v1:Int,_ v2:Int) -> Int { v1 - v2 }
    func multipe(_ 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 }
    
    func currying<A,B,C>(fn:@escaping (A,B) -> C) -> (B) -> (A) -> C {
        
        return {
            b in {
                a in
                fn(a,b)
            }
        }
        
    }

    print(currying(fn: addTest)(10)(20)).  // 20 + 10
    print(currying(fn: subTest)(10)(20)).  // 20 - 10
    print(currying(fn: multipeTest)(10)(20)).  //20*10
    print(currying(fn: modTest)(10)(20)).  //20%10
    print(currying(fn: divideTest)(10)(20)).  //20/10