F# 嵌套 List.iter 调用

Question

我有一个 F# 函数，我想尝试改变一些参数并测试所有这些组合。这是正确的方法吗？ （括号有点密集...）：

let MyFunc a b c x y z = 
  ...
  q


let UploadResult a b c x y z q =
  ...
  ()


let a = 5.0
let b = 0
let c = System.DateTime.Today
let xList = [-1.0; 0.0; 1.0]
let yList = [2; 4; 6; 8; 10]
let zList = [0.1; 0.001]

xList  |> List.iter (fun x ->
(yList |> List.iter (fun y ->
(zList |> List.iter (fun z ->
MyFunc a b c x y z 
|> UploadResult a b c x y z ))) ))
|> ignore

所以我想上传 3x5x2=30 个结果，并且写的很好。感谢您的任何建议。

Answer 1

对于像上传结果这样的纯命令式操作，我真的不会太担心。在您的代码示例中使用List.iter 可以解决问题。我可能更喜欢for 循环，因为很明显这段代码具有重要的副作用：

for x in xList do
  for y in yList do
    for z in zList do
      MyFunc a b c x y z |> UploadResult a b c x y z

如果你想做一些聪明的事情，你可以编写一个函数，从两个列表中生成所有参数组合：

let product xl yl = 
  seq { for x in xl do
          for y in yl do
            yield x, y }

好消息是您还可以多次使用它：product xList (product yList zList)。这将为您返回一个可以再次迭代的元组列表：

for (x,y), z in product (product xList yList) zList do
    MyFunc a b c x y z 
    |> UploadResult a b c x y z

这样不太好的事情是你最终会得到嵌套的元组——这就是为什么我可能只使用一个普通的循环。 （或者如果你总是有 3 个列表，那么另一个答案中的解决方案类似于 product，但针对 3 个列表进行了优化）

Answer 2

事实上，您的主要目标是创建一个由多个列表组成的跨积（或笛卡尔积），并且在 F# 中有几个被认为是“良好实践”的选项开发者：

1。 （删除for-comprehension，因为其他答案已经建议了这个）

2。使用计算表达式（在其他函数式编程世界中，它通常被称为 Monad）：

type Product () =
    member this.Bind (l,f) = List.collect f l    
    member this.Return n = [n]

let ret02 = Product() {
    let! x = xList
    let! y = yList
    let! z = zList
    MyFunc a b c x y z
    |> UploadResult a b c x y z
}

3。如果您只担心括号，请使用高优先级、右关联反向管道，(more info)

let inline (^<|) f a = f a

然后，您的代码将需要进行最少的修改（尽管仍然不是很干净）：

let ret03 =
    xList  |> List.iter ^<| fun x ->
    yList  |> List.iter ^<| fun y ->
    zList  |> List.iter ^<| fun z ->
        MyFunc a b c x y z
        |> UploadResult a b c x y z
        |> ignore

Answer 3

let MyFunc a b c x y z = 
    42

let UploadResult a b c x y z q =
    printfn "%A %A %A %A %A %A %A" a b c x y z q

let a = 5.0
let b = 0
let c = System.DateTime.Today
let xList = [-1.0; 0.0; 1.0]
let yList = [2; 4; 6; 8; 10]
let zList = [0.1; 0.001]

let perm xs ys zs =
    [for x in xs do
        for y in ys do 
            for z in zs do
                yield x,y,z]
let f (x,y,z) = MyFunc a b c  x y z |> UploadResult a b c  x y z
perm xList yList zList |> List.iter f