update: 动态库、静态库的编译链接细节

Chapter1 - iOS/1.125.md

@@ -1,4 +1,4 @@
-# Swift 函数式编程
+#  Swift 函数式编程
 
 ## 定义
 
@@ -46,7 +46,7 @@ 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)
@@ -87,43 +87,73 @@ print(rs)
 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 addThree(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 }
+func addThree(_ v1: Int) -> ((Int) -> (Int) -> Int) {
+    return { v2 in
+        return { v3 in
+            return v1 + v2 + v3
         }
-        
     }
 }
 
-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)
+func currying<A, B, C, D>(_ fn: @escaping (A, B, C) -> D) -> ((A) -> ((B) -> ((C) -> D))) {
+    return { v1 in
+        return { v2 in
+            return { v3 in
+                fn(v1, v2, v3)
             }
         }
     }
 }
 
-let rs1 = currying(add)(10)(20)
-let rs2 = currying(multipleAdd)(10)(20)(30)
-print(rs1, rs2) // 30 60
+print(addThree(1, 2, 3))						// 6
+print(addThree(1)(2)(3))						// 6
+print(currying(addThree)(1)(2)(3))	// 6
 ```
 
 
 
 ## 函子
 
- 像 Array、Optional 这样支持 map 运算的类型，称为函子(Functor)
+### 概念
+
+在函数式编程中，**函子（Functor）** 是一个核心概念，它表示一种可以**被映射**的容器或结构。简单来说，函子能够接受一个函数，将该函数应用到其内部的值上，并返回一个**保持原有结构**的新函子。
+
+函子存在3个特性：
+
+- **容器性**：函子是一个包装值的容器（`List` 等）
+- **可映射性**：通过 `map` 方法将函数应用到容器内的值，例如 `var array2 = [1, 2, 3].map { $0 + 1 }` 
+- **结构不变性**：映射过程不会改变容器的结构，例如数组的 `map` 方法返回新数组而非其他类型
+
+函子提供了一种**安全操作上下文中的值**的方式，是函数式编程中组合和抽象的基础工具。它通过 `map` 方法解耦了“值”和“上下文”，使得代码更模块化、可复用
+
+
+
+### 函子定律
+
+合法的函子必须满足以下规则：
+
+1. **恒等律**：`fmap id = id`（映射恒等函数后，容器不变）。
+2. **组合律**：`fmap (f . g) = fmap f . fmap g`（函数组合的映射等价于分别映射）
+
+
+
+### 总结
+
+像 Array、Optional 这样支持 map 运算的类型，称为函子(Functor)
+
 ```swift
- // Array<Element>
- public func map<T>(_ transform: (Element) -> T) -> Array<T>
+// Array<Element>
+@inlinable public func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
 
 // Optional<Wrapped>
-public func map<U>(_ transform: (Wrapped) -> U) -> Optional<U> 
+@inlinable public func map<U>(_ transform: (Wrapped) throws -> U) rethrows -> U?
+```
+
+跳出语言来看，符合函数式编程的语言都存在**函子** 这一概念，符合下面的形式，都可以叫函子
+
+```swift
+func map<T>(_ fn: (Element) -> T) -> Type<T>
 ```