函数式编程（Functional Programming）

函数式编程是一种以数学函数为核心抽象、以不可变数据和无副作用计算为基础的编程范式。 它将程序视为表达式之间的组合，而非一系列修改状态的命令。

一、命令式 vs 函数式：两种思维模型

• 命令式编程（Imperative Programming） 按照“程序是一系列改变状态的命令”来建模。 核心是 “怎么做” —— 你一步步告诉计算机执行什么操作。
• 函数式编程（Functional Programming） 将程序描述为表达式的组合和数据的变换。 核心是 “是什么” —— 定义数据之间的映射关系，而非操作过程。

换句话说，命令式编程像是“指挥演员演戏”， 函数式编程更像是“定义剧情规则，让演员自然演绎”。

二、核心思想：表达式与不可变性

函数式编程鼓励：

• 使用表达式（expression）而非语句（statement）；
• 数据不可变（immutable data）；
• 无副作用（pure function）；
• 函数为“一等公民”（First-class Function）。

它把底层细节（如内存管理、状态更新）交给运行时去优化， 开发者只需专注于描述输入与输出的关系。

这种思维带来的最大好处是：

控制权的上移 —— 从控制“怎么执行”，变成控制“怎么定义逻辑”。

三、函数式编程的三大核心操作

函数式编程往往围绕几种基础操作展开（以 List / Set / Map 为核心数据结构）：

1️⃣ filter（过滤）

保留满足条件的元素：

[1, 2, 3, 4, 5].filter(x => x % 2 === 0)
// → [2, 4]

2️⃣ map（映射）

将集合中的每个元素“映射”为新的值：

[1, 2, 3].map(x => x * 2)
// → [2, 4, 6]

3️⃣ reduce / fold（规约 / 折叠）

通过累加器把集合折叠为单个值：

[1, 2, 3, 4].reduce((acc, x) => acc + x, 0)
// → 10

filter / map / reduce 是函数式世界的“for 循环 + if + sum”三件套， 用声明式的方式表达数据转换。

四、函数式语言的权责转移

在函数式语言中，许多“命令式责任”被转移到语言运行时：

1. 底层迭代 → 高阶函数
   • 用 map、filter、reduce 替代显式 for 循环。
2. 状态管理 → 闭包与不可变变量
   • 不再维护共享变量，而是通过闭包捕获作用域。
3. 参数控制 → 柯里化（Currying）
   • process(x, y, z) 变为 process(x)(y)(z)。 每次调用返回一个新函数，就像“逐层工厂”。
4. 灵活复用 → 部分施用（Partial Application）
   • 给函数固定一部分参数，得到一个“定制版函数”： sum = add(5) → sum(3) = 8。

五、从迭代到递归：让逻辑自洽

函数式编程不鼓励显式循环，而使用递归表达重复。

传统迭代：

let sum = 0;
for (let i = 1; i <= 3; i++) sum += i;

函数式递归：

function sum(n) {
  return n === 0 ? 0 : n + sum(n - 1);
}

尾递归优化（Tail Recursion）

尾递归允许编译器复用调用栈，避免堆栈溢出：

function story() {
  // 尾递归：下一次调用不依赖当前栈
  return story(); 
}

与非尾递归的区别在于：

尾递归调用后没有额外逻辑 → 可直接返回结果。

六、函数式语言常见特性

1️⃣ 记忆（Memoization）

缓存函数结果以避免重复计算。 仅适用于纯函数（Pure Function）——即同输入、同输出、无副作用。

function memoize(fn) {
  const cache = {};
  return (...args) => {
    const key = JSON.stringify(args);
    return cache[key] ?? (cache[key] = fn(...args));
  };
}

函数式语言通常能天然支持记忆化，如：

(memoize (hash "homer"))

纯函数 + 不可变性 = 缓存安全。

2️⃣ 惰性求值（Lazy Evaluation）

表达式不会立即求值，而是在需要时才计算。 优点是节省资源、支持无限数据结构。

在 Java 中，可用 Stream 实现：

Stream.of(1, 2, 3)
      .filter(x -> x > 1)
      .map(x -> x * 2);

直到 .collect() 执行前，上述操作都不会真正运行。

七、函数式的重用机制

在 OOP 中，复用的单元是类或对象。 在 FP 中，复用的单元是函数。

由于函数式语言的核心数据结构少（多为 List / Map）， 重用往往通过“函数组合”完成。

例如：

const pipeline = compose(
  filter(isValid),
  map(parse),
  reduce(sum)
);

这种组合模式比继承更轻量、更安全。

八、设计模式在函数式世界的变形

在函数式语言中，许多 OOP 设计模式变得不再必要， 因为语言特性本身已经提供了解决方案。

示例：

class CustomerBlocks {
  def checkCredit, checkInventory, ship
  def process() {
    checkCredit()
    checkInventory()
    ship()
  }
}

在函数式中，这等价于：

const process = compose(checkCredit, checkInventory, ship);

OOP 通过“封装不确定因素”让代码易懂， FP 则通过“消除不确定因素”让代码易懂。

九、从函数式编程到函数式基础设施

函数式编程的哲学已渗透到现代架构中：

从“函数式编程”到“函数式基础设施”， 是软件工程抽象层次的一次跃迁。

🔚 十、总结

函数式编程不只是“另一种写法”， 而是一种从状态到变换、从控制到描述的思想转变。 它让我们更接近“数学意义上的确定性程序”。

十一、Haskell：函数式编程的纯正实现

如果说函数式编程是一种思想，那么 Haskell 就是这思想的实验场与结晶。 它不是“支持函数式”的语言，而是“由函数式原则构建”的语言。

1️⃣ Haskell 的设计哲学

• 纯度（Purity）： 所有函数都是纯函数，不能产生副作用。 与外部交互（如 I/O）必须通过 Monad 显式表示。
• 不可变性（Immutability）： 所有值都是常量，无法修改。 这让并发与推理变得安全。
• 惰性求值（Lazy Evaluation）： 表达式不会立即计算，而是在需要时求值。 支持无限序列与高性能管道。
• 强类型与类型推导（Strong & Inferred Typing）： 类型是函数式世界的“契约”，编译器可自动推导，保证安全。
• 函数即一等公民（First-Class Function）： 函数可以被当作参数、返回值、变量或数据结构成员。

这些设计，使 Haskell 成为“数学函数语义”最纯粹的语言。

2️⃣ 函数式核心概念在 Haskell 中的体现

换句话说，Haskell 把函数式编程的“理想”变成了语言约束。

3️⃣ 从命令式到函数式的对比：Haskell 的表达优势

4️⃣ Haskell 示例：从理念到实践

例 1：纯函数与类型声明

add :: Int -> Int -> Int
add x y = x + y

函数类型即契约：输入两个整数 → 输出一个整数 无副作用、可替换、可测试。

例 2：高阶函数与映射

map (*2) [1..5]
-- [2,4,6,8,10]

map 体现了“以函数为参数”的思想， 消除了显式循环与状态。

例 3：惰性求值与无限列表

take 5 [1..]
-- [1,2,3,4,5]

[1..] 是无限列表，但不会立即生成， take 5 才触发部分计算。

例 4：模式匹配与递归

factorial 0 = 1
factorial n = n * factorial (n - 1)

递归表达“定义本身”，而不是命令式的循环。

例 5：代数数据类型与类型安全

data Color = Red | Blue | Yellow
mix Red Blue = "Purple"

通过类型系统捕获语义错误， 每种可能性都被编译器穷尽检查（Exhaustive Checking）。

5️⃣ 哲学总结：Haskell 的函数式纯度之路

Haskell 的核心价值不只是“函数式语法”， 而是通过语言机制强制开发者：

• 思考 函数之间的关系，而非过程；
• 明确 副作用的边界；
• 借助 类型系统确保确定性；
• 让代码更接近 数学表达式的可推理性。

在这个意义上，Haskell 就像是“函数式编程的实验物理实验室”： 它让抽象思想以语言形式被验证、约束、实践。