如何顺序执行任务数组？F#代码规范性及mutable必要性问询

问题背景 #

需求为串行执行任务数组，记录每个任务执行前后的计时，避免并行执行（Task.WhenAll会触发并行）。遇到的核心问题是：let!绑定无法在普通Array.fold函数内使用（因为不在计算表达式上下文），因此引入了mutable累加器，需要确认这种写法是否符合F#惯用风格，以及mutable是否为必要选择。

用户提供的代码片段 #

初始框架代码 #

printfn "calling openai embeddings API"
let sw = System.Diagnostics.Stopwatch ()
sw.Start ()
let embs : MyRedis.RedisEmbedding array = 
    docs 
    |> MyOpenAI.rebuild2EmbeddingsSlow             
    
    // 待实现与评审的代码部分
    
sw.Stop ()
printfn "Artificially slowed down to %f" (sw.Elapsed.TotalSeconds)

无法编译的尝试代码（let!不在计算表达式内） #

|> Array.fold (fun s t -> 
    printfn "slow down - intermediate elapsed start %f " (sw.Elapsed.TotalSeconds)
    let! e1 = t
    printfn "intermediate elapsed end %f " (sw.Elapsed.TotalSeconds)
    Array.concat [| e1; s |]
) 

当前使用的带mutable的代码 #

printfn "calling openai embeddings API"
let sw = System.Diagnostics.Stopwatch ()
sw.Start ()
let embs : MyRedis.RedisEmbedding array = 
    docs 
    |> MyOpenAI.rebuild2EmbeddingsSlow             
    |> Array.fold (fun s t -> 
        let mutable acc = [||]
        printfn "slow down - intermediate elapsed start %f " (sw.Elapsed.TotalSeconds)
        task {
            let! e1 = t
            acc <- Array.append e1 s
        } |> Task.WaitAll
        printfn "intermediate elapsed end %f " (sw.Elapsed.TotalSeconds)
        acc
        ) 
        [| |]
sw.Stop ()
printfn "Artificially slowed down to %f" (sw.Elapsed.TotalSeconds)

代码分析与结论 #

关于let!的观点正确性 #

你认为let!无法直接在Array.fold普通函数内使用的观点是正确的。let!是计算表达式（如task、async）的专用绑定关键字，必须处于计算表达式的上下文中才能编译，普通函数不具备这个上下文。

mutable是否不可避免？ #

并非不可避免，当前代码的mutable使用可以优化，且现有写法存在一个明显问题：用Task.WaitAll阻塞主线程，违背了异步编程的非阻塞设计初衷，这在F#中是不推荐的。

符合F#惯用写法的优化方案 #

方案1：使用task计算表达式内的循环（局部mutable，非阻塞）

这种写法中mutable被限制在计算表达式的局部范围内，没有对外暴露可变状态，符合F#“局部可变可接受，全局可变需避免”的原则，同时保持异步非阻塞：

printfn "calling openai embeddings API"
let sw = System.Diagnostics.Stopwatch ()
sw.Start ()

// 用task计算表达式处理串行逻辑
let embsTask = task {
    let mutable acc = [||]
    for taskItem in docs |> MyOpenAI.rebuild2EmbeddingsSlow do
        printfn "slow down - intermediate elapsed start %f " (sw.Elapsed.TotalSeconds)
        let! result = taskItem
        acc <- Array.append result acc
        printfn "intermediate elapsed end %f " (sw.Elapsed.TotalSeconds)
    return acc
}

// 如果必须同步等待结果，使用.Result；如果上层也是异步上下文，改用let!
let embs = embsTask.Result

sw.Stop ()
printfn "Artificially slowed down to %f" (sw.Elapsed.TotalSeconds)

方案2：使用Array.foldAsync（完全避免mutable，函数式风格）

F# 6及以上版本支持Array.foldAsync，可以在异步上下文中完成累加，无需mutable，是更地道的函数式写法：

printfn "calling openai embeddings API"
let sw = System.Diagnostics.Stopwatch ()
sw.Start ()

let embs = 
    docs 
    |> MyOpenAI.rebuild2EmbeddingsSlow
    // 异步fold，每个步骤串行执行
    |> Array.foldAsync (fun accumulated taskItem -> task {
        printfn "slow down - intermediate elapsed start %f " (sw.Elapsed.TotalSeconds)
        let! result = taskItem
        printfn "intermediate elapsed end %f " (sw.Elapsed.TotalSeconds)
        return Array.append result accumulated
    }) [||]
    |> Task.Result

sw.Stop ()
printfn "Artificially slowed down to %f" (sw.Elapsed.TotalSeconds)

最终结论 #

• 你的let!使用限制的观点正确，但mutable并非必要。
• 当前代码的阻塞写法不符合异步编程的最佳实践，建议改用上述两种优化方案，既满足串行执行和计时需求，又符合F#的惯用风格。

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