Turn list of Result into Result of list inside a computation expression?

You have a Result<'a, 'e> list and want a Result<'a list, 'e>. That sounds like the sequence function described in https://fsharpforfunandprofit.com/posts/elevated-world-4/ (which has nothing to do with seqs, despite what the name sounds like). A quick check of https://github.com/fsharp/fsharp/blob/master/src/fsharp/FSharp.Core/result.fs suggests that this function hasn't been implemented in the standard FSharp.Core library, so you'll need to implement it yourself.

BTW, if you haven't already read Scott Wlaschin's "Elevated World" series, I don't recommend starting in the middle with the article I linked. Start with this article instead, as it builds the background knowledge you need to understand what the "traverse" and "sequence" functions do. Then you'll know the general pattern for implementing one of those functions.

As for your second question, could you provide a few more specifics? For example, what behavior do you want out of ResultBuilder.For? The normal behavior expected of a for expression would be to take a Result<'a, 'e> list (or seq or array) and run the inner block once for every Result<'a, 'e> that's in the list or seq or array. If you tried to use your all function here, you'd have a type mismatch between Result<'a, 'e> (which is what F# would expect a CE's .For method to produce) and Result<'a list, 'e> which is what your all method is returning. What specifically do you want your ResultBuilder.For method to do?

This functionality is provided by the FsToolkit.ErrorHandling package. The function List.sequenceResultM will return either:

• A Result.Ok containing a list of all Ok values
• Or, a Result.Error containing just the first Error value

There is also a variant List.sequenceResultA that returns a list of all errors found.

#r "nuget: FsToolkit.ErrorHandling, 2.0.0"

open FsToolkit.ErrorHandling

let xs : Result<int, string> list =
  [
    Ok 123
    Ok 456
  ]

let xa = List.sequenceResultA xs // Ok [123; 456]
let xm = List.sequenceResultM xs // Ok [123; 456]

printfn "xa: %A" xa
printfn "xm: %A" xm

let ys =
  [
    Ok 123
    Ok 456
    Error "abc"
    Ok 789
  ]

let ya = List.sequenceResultA ys // Error ["abc"]
let ym = List.sequenceResultM ys // Error "abc"

printfn "ya: %A" ya
printfn "ym: %A" ym

let zs =
  [
    Ok 123
    Error "abc"
    Error "def"
    Ok 456
  ]

let za = List.sequenceResultA zs // Error ["abc"; "def"]
let zm = List.sequenceResultM zs // Error "abc"

printfn "za: %A" za
printfn "zm: %A" zm

xa: Ok [123; 456]
xm: Ok [123; 456]
ya: Error ["abc"]
ym: Error "abc"
za: Error ["abc"; "def"]
zm: Error "abc"

In terms of computation expressions (also provided by FsToolkit.ErrorHandling), you could do:

#r "nuget: FsToolkit.ErrorHandling, 2.0.0"

open FsToolkit.ErrorHandling

let printAll xs =
  result {
    let! xs = List.sequenceResultA xs

    for x in xs do
      printfn "%A" x
  }