docs: clang 插件开发

Chapter1 - iOS/1.125.md

@@ -0,0 +1,190 @@
+# Swift 函数式编程
+
+## 定义
+
+ 函数式编程（Funtional Programming，简称 FP）是一种编程范式，也就是如何编写程序的方法论
+
+- 主要思想：把计算过程尽量分解成一系列可复用函数的调用
+- 主要特征：函数是“第一等公民”。函数与其他数据类型一样的地位，可以赋值给其他变量，也可以作为函数参数、函数返回值
+
+
+
+函数式编程最早出现在 LISP 语言，绝大部分的现代编程语言也对函数式编程做了不同程度的支持，比如：Haskell、JavaScript、Python、Swift、Kotlin、Scala 等
+
+
+
+函数式编程中几个常用的概念：
+
+- Higher-Order Function、Function Currying
+- Functor、Applicative Functor、Monad
+
+
+
+## 高阶函数
+
+ 高阶函数是至少满足下列一个条件的函数:
+
+- 接受一个或多个函数作为输入（map、filter、reduce等）
+- 返回一个函数
+
+FP中到处都是高阶函数
+
+
+
+## 柯里化（Currying）
+
+将一个接受多个参数的函数变换成为一系列只接受单个参数的函数
+
+Demo：
+
+```swift
+// 函数式编程，为了过程的复用
+let num = 10
+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)) }
+}
+
+// result = ((((x + 3)*5) - 1 )%10)/2
+let fn = add(3) >>> multiple(5) >>> sub(1) >>> mod(10) >>> divide(2)
+
+print(fn(num))
+
+
+func multipleAdd(_ v1: Int) -> ((Int) -> ((Int) -> Int))  {
+    return { v2 in
+        return { v3 in
+            return
+                v1 + v2 + v3
+        }
+    }
+}
+
+/*
+ - multipleAdd(1)，调用函数，传递1给参数V3，此时继续返回一个函数。
+ - multipleAdd(1)(2) 拿着上一步返回的函数，再去调用，传入的2给参数V2.此时继续返回一个函数
+ - multipleAdd(1)(2)(3) 拿着上一步返回的函数，再去调用，此时传入的3给参数V1，此时则执行相加操作。V1 + V2 + V3
+ */
+let rs = multipleAdd(1)(2)(3)
+print(rs)
+```
+
+参数对应如下图圈选部分
+
+<img src="https://github.com/FantasticLBP/knowledge-kit/raw/master/assets/SwiftFunctionalProgrammingCurrying.png" style="zoom:25%">
+
+
+
+Demo2：将一个三个参数的函数变成柯里化
+
+```swift
+func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
+func multipleAdd(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 }
+func currying<A, B, C>(_ fn: @escaping (A, B) -> C) -> ((A) -> ((B) -> C)) {
+    return { a in
+        return { b in
+            return fn(a, b)
+        }
+        
+    }
+}
+
+func currying<A, B, C, D>(_ fn: @escaping (A, B, C) -> D) -> ((A) -> ((B) -> ((C) -> D ))) {
+    return { a in
+        return { b in
+            return { c in
+                return fn(a, b, c)
+            }
+        }
+    }
+}
+
+let rs1 = currying(add)(10)(20)
+let rs2 = currying(multipleAdd)(10)(20)(30)
+print(rs1, rs2) // 30 60
+```
+
+
+
+## 函子
+
+ 像 Array、Optional 这样支持 map 运算的类型，称为函子(Functor)
+```swift
+ // Array<Element>
+ public func map<T>(_ transform: (Element) -> T) -> Array<T>
+
+// Optional<Wrapped>
+public func map<U>(_ transform: (Wrapped) -> U) -> Optional<U> 
+```
+
+
+
+## 适用函子(Applicative Functor)
+对任意一个函子 F，如果能支持以下运算，该函子就是一个适用函子
+```swift
+func pure<A>(_ value: A) -> F<A>
+func <*><A, B>(fn: F<(A) -> B>, value: F<A>) -> F<B>
+```
+
+ Array 可以成为适用函子
+
+```swift
+func pure<A>(_ value: A) -> [A] {
+    [value]
+}
+
+infix operator <*> : AdditionPrecedence
+func <*><A, B>(fn:[(A) -> B], value: [A]) -> [B] {
+    var resultArray: [B] = []
+    if fn.count == value.count {
+        for i in fn.startIndex..<fn.endIndex {
+            resultArray.append(fn[i](value[i]))
+        }
+    }
+    return resultArray
+}
+print(pure(10))
+
+var array = [{$0 * 2}, {$0 + 10}, {$0 - 5}] <*> [1, 2, 3]
+print(array)
+// console
+[10]
+[2, 12, -2]
+```
+
+
+
+## 单子
+
+ 对任意一个类型 F，如果能支持以下运算，那么就可以称为是一个单子（Monad）
+
+```swift
+func pure<A>(_ value: A) -> F<A>
+func flatMap<A, B>(_ value: F<A>, _ fn: (A) -> F<B>) -> F<B>
+```
+
+ 很显然，Array、Optional 都是单子
+
+
+
+“单子”（Monad）是一个抽象概念，它代表了一种设计模式，用于组合计算并管理可能包含副作用的值。单子是一种在函数式编程中用于封装和组合计算的通用结构，它允许程序员以一致的方式处理各种复杂的计算情况，包括错误处理、异步操作、状态管理等。
+
+单子通常定义了几个操作，这些操作允许你以统一的方式对封装在单子中的值进行操作。这些操作包括：
+
+- `return` 或 `pure`：将一个值“提升”到单子中。
+- `bind` 或 `flatMap`：用于组合单子中的计算，允许你将一个单子的输出作为另一个单子的输入。
+
+在 Swift 中，单子并没有像在其他一些语言（如 Haskell 或 Scala）中那样作为语言内建的概念，但你可以通过定义自己的类型和方法来实现单子模式。例如，Swift 中的 `Optional` 类型可以看作是一个简单的单子，它表示一个值可能存在或不存在。`Optional` 提供了 `map` 和 `flatMap` 方法，允许你对封装的值进行链式操作。
+
+其他常见的单子实现包括处理异步操作的单子（如 Promise 或 Future），处理错误和异常的单子，以及管理状态的单子（如 State Monad）。
+
+单子提供了一种强大的方式来管理复杂性和副作用，使代码更易于理解和测试。然而，它们也增加了抽象层次，可能需要一些时间来适应和理解。在 Swift 中，你可以根据自己的需要选择是否使用单子，以及使用哪种类型的单子。