如何组合结果列表<&燃气轮机；在F#中？

使用此代码：

let a = [3; 4; 5; 6; 7]
let check x = if x % 2 = 0 then Ok x else Error x
let b = a |> List.map check

我如何将B总结为：

• 如果一切都好，那就好
• 如果有任何错误，则为错误

---

我可以用一种方法来实现这一点，但我忍不住认为这必须是内置的，或者必须有一种聪明的简单方法来实现（我有FsToolkit.ErrorHandling顺便说一句，以防它内置在那里。

如果我正确理解了你的问题，你正在寻找一个

遍历
或
映射
函数。
它们不是内置在本机fsharp中的，但实现是存在的。我不会在这里链接到特定的库，因为新库可能会在稍后弹出

您可以在此处了解更多信息：
如果我正确理解了您的问题，您正在寻找
遍历
或
mapM
函数。
它们不是内置在本机fsharp中的，但实现是存在的。我不会在这里链接到特定的库，因为新库可能会在稍后弹出

您可以在此处了解更多信息：
一旦您意识到要将
结果列表
转换为单个
结果
，实际上您可以自己编写函数

模块结果=
let of list arg=
（arg，Ok[]）| |>List.foldBack（funt t s->
将t、s与
|Ok x，Ok xs->Ok（x:：xs）//到目前为止一切正常，在状态之前
|错误e，确定->错误[e]//第一个错误，放弃累积状态
|确定u3;，错误es->错误es//忽略第一个错误后的每个确定
|错误e，错误es->错误（e:：es））//第二个或更高版本的错误，前置到状态
//列表值：arg:结果列表->结果
[3; 4; 5; 6; 7]
|>List.map（乐趣x->如果x%2=0，则确定x否则错误x）
|>列表的结果
//val it:Result=错误[3；5；7]
一旦您意识到要将
结果列表
转换为单个
结果
，实际上您可以自己编写函数

模块结果=
let of list arg=
（arg，Ok[]）| |>List.foldBack（funt t s->
将t、s与
|Ok x，Ok xs->Ok（x:：xs）//到目前为止一切正常，在状态之前
|错误e，确定->错误[e]//第一个错误，放弃累积状态
|确定u3;，错误es->错误es//忽略第一个错误后的每个确定
|错误e，错误es->错误（e:：es））//第二个或更高版本的错误，前置到状态
//列表值：arg:结果列表->结果
[3; 4; 5; 6; 7]
|>List.map（乐趣x->如果x%2=0，则确定x否则错误x）
|>列表的结果
//val it:Result=错误[3；5；7]
在这里的回复中有很多很酷的想法，但我认为这些想法对于所描述的问题来说是过火了。因此，作为记录，这里有一个非常简单的解决方案：

let a = [3; 4; 5; 6; 7]
let check x = (x % 2 = 0), x
let b =
    a
        |> List.map check
        |> List.partition fst
        |> function
            | evens, [] -> Ok evens
            | _, odds -> Error odds

在这里的回答中有很多很酷的想法，但我认为这些想法对于所描述的问题来说是过分的。因此，为了记录在案，这里有一个非常简单的解决方案：

let a = [3; 4; 5; 6; 7]
let check x = (x % 2 = 0), x
let b =
    a
        |> List.map check
        |> List.partition fst
        |> function
            | evens, [] -> Ok evens
            | _, odds -> Error odds

您需要的函数是
FsToolkit.ErrorHandling
的列表函数中的
traverseResultA
。请参见其中的“这是应用程序，收集所有错误。将示例…与traverseResultM进行比较。”（后者是获取第一个错误的monad）

#r“nuget:FsToolkit.ErrorHandling”
打开FsToolkit.ErrorHandling
设a=[3；4；5；6；7]
设aOk=[4；6]
设aError=[3；5；7]
让我们检查x=如果x%2=0，则确定x否则错误x
>
val a:int list=[3；4；5；6；7]
val aOk:int list=[4；6]
val-aError:int-list=[3；5；7]
val检查：x:int->Result
aOk |>List.traverseResultA检查
>
val it:Result=Ok[4；6]
aError |>List.traverseResultA检查
>
val it:Result=错误[3；5；7]
a |>List.traverseResultA检查
>
val it:Result=错误[3；5；7]

显式版本可以是：

let traverseResultA data =
    let value = function Ok x -> x | Error y -> y 
    let filter = function Ok _ -> true | Error _ -> false
    if List.forall filter data then data |> List.map value |> Ok
    else data |> List.filter (not<<filter) |> List.map value |> Error
> 
val traverseResultA : data:Result<'a,'a> list -> Result<'a list,'a list>

让遍历结果数据=
设值=功能正常x->x |错误y->y
让过滤器=功能正常->正确|错误->错误
如果List.forall筛选数据，则数据|>List.map值|>Ok
else data |>List.filter（非错误
> 
val遍历结果：数据：结果列表->结果

另请参见Scott's，了解traverse和Applications与Monad的对比。
您需要的函数是
FsToolkit.ErrorHandling的列表函数中的
traverseResultA
。请参见其中的“这是应用程序，收集所有错误。将示例与traverseResultM进行比较。”（后者是获得第一个错误的monad）

#r“nuget:FsToolkit.ErrorHandling”
打开FsToolkit.ErrorHandling
设a=[3；4；5；6；7]
设aOk=[4；6]
设aError=[3；5；7]
让我们检查x=如果x%2=0，则确定x否则错误x
>
val a:int list=[3；4；5；6；7]
val aOk:int list=[4；6]
val-aError:int-list=[3；5；7]
val检查：x:int->Result
aOk |>List.traverseResultA检查
>
val it:Result=Ok[4；6]
aError |>List.traverseResultA检查
>
val it:Result=错误[3；5；7]
a |>List.traverseResultA检查
>
val it:Result=错误[3；5；7]

显式版本可以是：

let traverseResultA data =
    let value = function Ok x -> x | Error y -> y 
    let filter = function Ok _ -> true | Error _ -> false
    if List.forall filter data then data |> List.map value |> Ok
    else data |> List.filter (not<<filter) |> List.map value |> Error
> 
val traverseResultA : data:Result<'a,'a> list -> Result<'a list,'a list>

让遍历结果数据=
设值=功能正常x->x |错误y->y
让过滤器=功能正常->正确|错误->错误
如果List.forall筛选数据，则数据|>List.map值|>Ok
else data |>List.filter（非错误
> 
val遍历结果：数据：结果列表->结果

另请参见Scott’s，以解释遍历和应用程序与单子的区别。
在
Error
中的
int list
是什么？所有错误项的集合；因此，如果所有ok，则ok有一个所有ok值的列表，如果有错误，则Error有一个所有错误的列表，您将在
结果中返回值
 ，它同构于
bool*int
。就我个人而言，我只会返回该元组类型，然后使用
List.partition>>fst
来拆分它们。对这样一个函数的请求并不少见。因此，使用F#+可以通过