Swift二十(函数式编程)

一: 函数式编程（Funtional Programming）

函数式编程（Funtional Programming，简称FP）是一种编程范式，也就是如何编写程序的方法论
主要思想：把计算过程尽量分解成一系列可复用函数的调用
主要特征：函数是“第一等公民”
函数与其他数据类型一样的地位，可以赋值给其他变量，也可以作为函数参数、函数返回值
函数式编程最早出现在LISP语言，绝大部分的现代编程语言也对函数式编程做了不同程度的支持，比如 Haskell、JavaScript、Python、 、Kotlin、Scala等
函数式编程中几个常用的概念
Higher-Order Function、Function Currying、 Functor、Applicative Functor、Monad

传统写法 & 函数式编程

// 假设要实现以下功能：[(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 add(_ v: Int) -> (Int) -> Int { { $0 + v } }
func sub(_ v: Int) -> (Int) -> Int { { $0 - v } }
func multiple(_ v: Int) -> (Int) -> Int { { $0 * v } }
func divide(_ v: Int) -> (Int) -> Int { { $0 / v } }
func 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 = add(3) >>> multiple(5) >>> sub(1) >>> mod(10) >>> divide(2)
fn(num) 

二: 高阶函数

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

• 接受一个或多个函数作为输入（map、filter、reduce等）
• 返回一个函数
• FP中到处都是高阶函数
  func add(_ v: Int) -> (Int) -> Int { { $0 +v } }

三: 柯里化（Currying）

• 什么是柯里化？
  将一个接受多参数的函数变换为一系列只接受单个参数的函数

    override func viewDidLoad() {
        super.viewDidLoad()
        print(add(1, 2)) // 3
        print(addNew(1)(2)) // 3
    }
    // 接受多参数的函数
    func add(_ num1: Int, _ num2: Int) -> Int {
        num1 + num2
    }
    // ---> 变成 接受单个参数的函数
    func addNew(_ num: Int) -> (Int) -> Int {
        {(value: Int) -> Int in
            num + value    // {$0 + num}
        }
    }

四: 函子（Currying）

• 1 函子 像Array、Optional这样支持map运算的类型，称为函子（Functor）
  1 数组元素类型和返会数组元素类型类型相同
  2 闭包形参是每个内部数组元素
  3 闭包返回值类型和原元素,返回数组元素类型相同

// 函子: 需要符合下面公式
// Array<Element>
public func map<T>(_ transform: (Element) -> T) -> Array<T>
// Optional<Wrapped>
public func map<U>(_ transform: (Wrapped) -> U) -> Optional<U>

• 2 适用函子（Applicative Functor）
  Array 可以成为适用函子

func pure<A>(_ value: A) -> [A] { [value] }
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
}
// [10]
print(pure(10))
var arr = [{ $0 * 2}, { $0 + 10 }, { $0 - 5 }] <*> [1, 2, 3]
// [2, 12, -2]
print(arr)

• **3 单子（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都是单子