如何在不调用unsafe方法的情况下用fold合并IO[Result]结果

}

需要实现`save`函数，接收`Record`列表，通过`combineStorageResults`将所有处理结果合并为单个`Result`：
```scala
def combineStorageResults(result1: Result, result2: Result) = {
  Result(result1.c + result2.c, result1.d / 2 + result2.d / 2)
}

当前的save实现使用foldLeft但在循环中调用了unsafeRunSync，破坏了异步非阻塞特性，现寻求无需调用任何unsafe方法的实现：

def save(records: Seq[Record]): Future[Result] = {
    IO(records.foldLeft(Result(0, 0))((previousResult, evt) => {
        val processedResult = processRecord(evt).unsafeRunSync()
        combineStorageResults(previousResult, processedResult)
      }
    )).unsafeToFuture()  
} 

串行处理（与原实现逻辑一致） #

使用IO的链式调用替代阻塞的unsafeRunSync，通过foldLeft逐步累积异步结果：

import cats.effect.IO
import scala.concurrent.Future

def save(records: Seq[Record]): Future[Result] = {
  val initial = Result(0, 0)
  records.foldLeft(IO.pure(initial)) { (accIO, record) =>
    for {
      currentAcc <- accIO
      processed <- processRecord(record)
    } yield combineStorageResults(currentAcc, processed)
  }.unsafeToFuture()
}

并行处理（可选，需注意合并逻辑的顺序影响） #

如果业务允许并行处理所有Record，可以先通过IO.traverse批量执行异步任务，再合并结果：

def saveParallel(records: Seq[Record]): Future[Result] = {
  val initial = Result(0, 0)
  IO.traverse(records)(processRecord)
    .map(_.foldLeft(initial)(combineStorageResults))
    .unsafeToFuture()
}

1. 原代码中processRecord的泛型参数写法有误，已修正为def processRecord(record: Record): IO[Result]，否则无法通过编译。
2. 串行方案完全保留原实现的执行顺序，每个processRecord任务在前一个完成后才启动，全程异步非阻塞，仅在最后为了满足返回Future的要求调用unsafeToFuture（若允许返回IO[Result]可移除该调用）。
3. 并行方案适合无顺序依赖的场景，但需注意combineStorageResults中d/2的整数除法逻辑会因合并顺序变化导致结果不同，需根据业务需求选择。

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