如何将针对lazy sequence的多个for循环合并为单次迭代的fold？

你描述的这种将多个独立遍历逻辑合并为单次遍历的技术，在函数式编程中通常被称为多折叠（multi-folding），或者更广泛地归类于**折叠组合（fold composition）**的范畴。它的核心思路就是把多个独立的fold操作打包成一个处理复合状态（比如元组）的单一fold，从而只遍历一次lazy序列，同时保持各个逻辑的独立性。

实现思路 #

每个独立的统计逻辑都可以拆解为：

• 一个初始状态值（比如合数计数初始为0，质数和初始为0）
• 一个状态更新函数（比如遇到合数则计数+1，遇到质数则累加其值）

将这些初始值打包成一个复合状态（如元组(合数计数, 质数和)），再编写一个能同时更新所有子状态的函数，最后用这个复合状态和更新函数执行一次fold即可。

具体示例（Haskell） #

以你提到的统计合数数量、计算质数之和为例：

首先定义辅助判断函数：

isPrime :: Int -> Bool
isPrime n | n <= 1    = False
          | otherwise = all (\k -> n `mod` k /= 0) [2..floor (sqrt (fromIntegral n))]

isComposite :: Int -> Bool
isComposite n = n > 1 && not (isPrime n)

方法1：手动编写复合折叠

直接把两个逻辑的更新逻辑合并到一个fold中，既保证单次遍历，又能单独修改每个逻辑：

computeStats :: [Int] -> (Int, Int)
computeStats = foldl update (0, 0)
  where
    -- 同时更新合数计数和质数和
    update (compositeCount, primeSum) x = 
      ( compositeCount + if isComposite x then 1 else 0
      , primeSum + if isPrime x then x else 0
      )

如果需要修改其中一个逻辑（比如把质数和改成质数个数），只需要修改primeSum对应的更新部分，完全不影响合数计数的逻辑。

方法2：利用Monoid优雅实现

Haskell的Monoid类型类可以自动组合多个累积结果，配合foldMap可以更简洁地实现多折叠，同样只遍历一次序列：

import Data.Monoid (Sum(..))

computeStats :: [Int] -> (Int, Int)
computeStats xs = 
  let (Sum compositeCount, Sum primeSum) = 
        foldMap (\x -> ( Sum (if isComposite x then 1 else 0)
                       , Sum (if isPrime x then x else 0)
                       )) xs
  in (compositeCount, primeSum)

这里foldMap会遍历序列一次，对每个元素生成包含两个Sum值的元组，再通过Monoid的mappend自动累积所有元组的对应部分。

相关概念与资料方向 #

• 核心技术属于折叠组合（fold composition），常和Applicative 风格折叠、Monoid 组合一起讨论
• Haskell标准库中，Data.Foldable模块的foldMap是实现这种模式的核心工具；你也可以基于Applicative编写通用的多折叠组合函数，将任意多个独立fold打包成一个
• 这种模式的本质是将多个独立的状态转换合并为一个复合状态转换，从而复用单次遍历的成本，同时保持各个逻辑的模块化

内容的提问来源于stack exchange，提问作者Zoey Hewll