docs(GFramework.Core): 添加Pipe扩展方法文档

- 新增函数式编程扩展方法的详细说明文档
- 包含管道操作、函数组合、柯里化等20种核心功能介绍
- 提供每种方法的具体用法示例和代码片段
- 添加链式操作和函数组合的实际应用场景
- 补充注意事项和适用场景说明

GFramework.Core/functional/pipe/README.md

@@ -0,0 +1,215 @@
+# Pipe Extensions - 函数式编程扩展方法
+
+提供了一系列用于函数式编程的管道和组合操作扩展方法。
+
+## 功能概览
+
+这些扩展方法实现了函数式编程的核心概念，包括管道操作、函数组合、柯里化、模式匹配等功能，使C#代码更加简洁和函数式。
+
+## 方法列表及用法
+
+### 1. Pipe - 管道操作
+```csharp
+// 将值传入函数进行处理
+var result = 5.Pipe(x => x * 2); // 结果为 10
+```
+
+### 2. Then - 函数组合
+```csharp
+// 组合两个函数，先执行first再执行second
+Func<int, int> addTwo = x => x + 2;
+Func<int, int> multiplyByThree = x => x * 3;
+var composed = addTwo.Then(multiplyByThree); // 先+2再*3
+var result = composed(5); // (5+2)*3 = 21
+```
+
+### 3. After - 反向组合
+```csharp
+// 与Then相反，以不同的顺序组合函数
+Func<int, int> multiplyByThree = x => x * 3;
+Func<int, int> addTwo = x => x + 2;
+var composed = multiplyByThree.After(addTwo); // 先+2再*3
+var result = composed(5); // (5+2)*3 = 21
+```
+
+### 4. Tap - 执行副作用
+```csharp
+// 执行副作用操作但返回原值，常用于调试或日志记录
+var value = 42.Tap(Console.WriteLine); // 输出42，但value仍为42
+```
+
+### 5. Map - 映射操作
+```csharp
+// 对集合中的每个元素应用函数
+var numbers = new[] {1, 2, 3, 4};
+var squared = numbers.Map(x => x * x); // {1, 4, 9, 16}
+```
+
+### 6. Filter - 过滤操作
+```csharp
+// 过滤集合中的元素
+var numbers = new[] {1, 2, 3, 4, 5, 6};
+var evens = numbers.Filter(x => x % 2 == 0); // {2, 4, 6}
+```
+
+### 7. Reduce - 归约操作
+```csharp
+// 将集合归约为单个值
+var numbers = new[] {1, 2, 3, 4};
+var sum = numbers.Reduce(0, (acc, x) => acc + x); // 10
+```
+
+### 8. Apply - 应用函数
+```csharp
+// 将参数应用于函数
+Func<int, int> multiplyByTwo = x => x * 2;
+var result = multiplyByTwo.Apply(5); // 10
+```
+
+### 9. Curry - 柯里化
+```csharp
+// 将多参数函数转换为链式单参数函数
+Func<int, int, int> add = (x, y) => x + y;
+var curriedAdd = add.Curry(); // 返回 Func<int, Func<int, int>>
+var addFive = curriedAdd(5); // 返回 Func<int, int>
+var result = addFive(3); // 8
+```
+
+### 10. Uncurry - 取消柯里化
+```csharp
+// 将柯里化函数转换回多参数函数
+var curriedAdd = ((Func<int, int, int>)((x, y) => x + y)).Curry();
+var uncurriedAdd = curriedAdd.Uncurry(); // 返回 Func<int, int, int>
+var result = uncurriedAdd(5, 3); // 8
+```
+
+### 11. Partial - 部分应用
+```csharp
+// 固定函数的部分参数
+Func<int, int, int> multiply = (x, y) => x * y;
+var double = multiply.Partial(2); // 固定第一个参数为2
+var result = double(5); // 10
+```
+
+### 12. Match - 模式匹配
+```csharp
+// 基于条件的模式匹配
+var result = 5.Match(
+    (x => x < 0, _ => "负数"),
+    (x => x > 0, _ => "正数"),
+    (x => x == 0, _ => "零")
+); // "正数"
+```
+
+### 13. MatchOrDefault - 带默认值的模式匹配
+```csharp
+// 模式匹配，无匹配时返回默认值
+var result = 0.MatchOrDefault("未知数字",
+    (x => x < 0, _ => "负数"),
+    (x => x > 0, _ => "正数")
+); // "未知数字"
+```
+
+### 14. If / IfElse - 条件执行
+```csharp
+// 条件执行操作
+var result = 5.If(x => x > 0, x => x * 2); // 10 (因为5>0，所以乘以2)
+var result2 = 5.IfElse(
+    x => x > 10, 
+    x => x * 2,      // 条件为真时执行
+    x => x + 1       // 条件为假时执行
+); // 6 (因为5不大于10，所以+1)
+```
+
+### 15. As / Cast - 类型转换
+```csharp
+// 安全类型转换
+object obj = "Hello";
+var str = obj.As<string>(); // "Hello"
+var str2 = obj.Cast<string>(); // "Hello" (强制转换)
+```
+
+### 16. Also / Let - 副作用和转换
+```csharp
+// 执行操作并返回原值
+var value = 42.Also(Console.WriteLine); // 输出42，返回42
+
+// 转换值
+var result = 5.Let(x => x * 2); // 10
+```
+
+### 17. TakeIf / TakeUnless - 条件取值
+```csharp
+// 条件为真时返回值，否则返回null
+string str = "Hello";
+var result1 = str.TakeIf(s => s.Length > 3); // "Hello"
+var result2 = str.TakeIf(s => s.Length < 3); // null
+
+// 条件为假时返回值，否则返回null
+var result3 = str.TakeUnless(s => s.Length > 10); // "Hello" (因为长度不大于10)
+var result4 = str.TakeUnless(s => s.Length > 3);  // null (因为长度大于3)
+```
+
+### 18. Repeat - 重复执行
+```csharp
+// 重复执行函数n次
+var result = 2.Repeat(3, x => x * 2); // 2 -> 4 -> 8 -> 16
+```
+
+### 19. Try - 安全执行
+```csharp
+// 安全执行可能抛出异常的函数
+var (success, result, error) = 10.Try(x => 100 / x); // 成功，result为10
+var (success2, result2, error2) = 0.Try(x => 100 / x); // 失败，success2为false
+```
+
+### 20. Memoize - 缓存结果
+```csharp
+// 缓存函数结果以提高性能
+Func<int, int> expensiveFunction = x => 
+{
+    // 模拟耗时操作
+    System.Threading.Thread.Sleep(1000);
+    return x * x;
+};
+var memoized = expensiveFunction.Memoize();
+var result1 = memoized(5); // 首次调用需要1秒
+var result2 = memoized(5); // 立即返回，使用缓存结果
+```
+
+## 使用示例
+
+### 链式操作
+```csharp
+var result = new[] {1, 2, 3, 4, 5}
+    .Filter(x => x % 2 == 0)        // 过滤偶数: {2, 4}
+    .Map(x => x * x)               // 平方: {4, 16}
+    .Reduce(0, (sum, x) => sum + x); // 求和: 20
+```
+
+### 函数组合
+```csharp
+// 创建复合函数
+Func<int, int> addTwo = x => x + 2;
+Func<int, int> square = x => x * x;
+Func<int, int> subtractOne = x => x - 1;
+
+// 组合多个函数
+var complexOperation = addTwo.Then(square).Then(subtractOne);
+var result = complexOperation(3); // ((3+2)^2)-1 = 24
+```
+
+## 注意事项
+
+- 部分方法（如Memoize）对泛型参数有约束（例如`where TSource : notnull`）
+- Try方法返回元组，便于处理可能发生的异常
+- 柯里化和部分应用有助于创建更灵活的函数
+- 链式操作可以提高代码可读性，但要注意性能影响
+
+## 适用场景
+
+- 数据转换和处理管道
+- 函数组合和复用
+- 避免中间变量的创建
+- 提高代码的声明式风格
+- 创建可重用的功能组件