F# 什么'；这是Seq.iter的替代方案，以便我可以返回最后一项的操作结果？

有什么方法可以替代Seq.iter，以便返回最后一项的操作结果？

Seq.iter返回一个单位。但是，我希望遍历我的集合并返回最后一个结果

考虑以下代码：

let updatedGrid = grid |> Map.toSeq
                       |> Seq.map snd
                       |> Seq.iter (fun c -> grid |> setCell c 

let setCell cell (grid:Map<(int * int), Cell>) =

    grid |> Map.map (fun k v -> match k with
                                | c when c = (cell.X, cell.Y) -> { v with State=cell.State }
                                | _ -> v)

let cycleThroughCells (grid:Map<(int * int), Cell>) =

    let updatedGrid = grid |> Map.toSeq
                           |> Seq.map snd
                           |> Seq.iter (fun c -> grid |> setCell c 
                                                      |> ignore) 
    updatedGrid

注意：SetCell返回一个新映射：

以下是实际代码：

let updatedGrid = grid |> Map.toSeq
                       |> Seq.map snd
                       |> Seq.iter (fun c -> grid |> setCell c 

let setCell cell (grid:Map<(int * int), Cell>) =

    grid |> Map.map (fun k v -> match k with
                                | c when c = (cell.X, cell.Y) -> { v with State=cell.State }
                                | _ -> v)

let cycleThroughCells (grid:Map<(int * int), Cell>) =

    let updatedGrid = grid |> Map.toSeq
                           |> Seq.map snd
                           |> Seq.iter (fun c -> grid |> setCell c 
                                                      |> ignore) 
    updatedGrid

let setCell单元格（网格：Map）=
grid |>Map.Map（趣味k v->将k与
|当c=（cell.X，cell.Y）->{v with State=cell.State}
|_uv）
让循环遍历单元格（栅格：贴图）=
让updateGrid=grid |>Map.toSeq
|>序列图snd
|>国际热核聚变实验堆（趣味c->grid |>setCell c
|>忽略）
更新网格

同样，我只想得到iter函数中最后一次运算的结果

[更新]

我认为这是可行的（使用地图）：

let cyclethrawcells（网格：Map）=
让updateGrid=grid |>Map.toSeq
|>序列图snd
|>Seq.map（乐趣c->grid |>setCell c）
|>倒数第二
更新网格

我认为不存在，但您可以使用

折叠定义自己的：

let tapSeq f s = Seq.fold (fun _ x -> f x; Some(x)) None s

我认为不存在，但您可以使用
fold
定义您自己的：

let tapSeq f s = Seq.fold (fun _ x -> f x; Some(x)) None s

正如我在一篇评论中所说的，似乎您几乎肯定想要折叠，以便将更新的网格传递给每个后续调用；否则，除最后一个修改外，所有修改都将被删除

我认为这会起作用：

let cycleThroughCells (grid:Map<(int * int), Cell>) =
    grid 
    |> Map.toSeq
    |> Seq.map snd
    |> Seq.fold (fun grid c -> grid |> setCell c) grid

let cyclethrawcells（网格：Map）=
网格
|>托塞克地图
|>序列图snd
|>Seq.fold（趣味网格c->grid |>setCell c）网格

如果您将参数重新排序为
setCell
，使
grid
参数排在第一位，那么最后一行可以是
|>Seq.fold setCell grid
，就像我在一篇评论中所说的那样，您几乎肯定需要折叠，以便将更新后的网格传递给每个后续调用；否则，除最后一个修改外，所有修改都将被删除

我认为这会起作用：

let cycleThroughCells (grid:Map<(int * int), Cell>) =
    grid 
    |> Map.toSeq
    |> Seq.map snd
    |> Seq.fold (fun grid c -> grid |> setCell c) grid

let cyclethrawcells（网格：Map）=
网格
|>托塞克地图
|>序列图snd
|>Seq.fold（趣味网格c->grid |>setCell c）网格

如果您将参数重新排序为
setCell
，使
grid
参数排在第一位，那么最后一行可以是
|>Seq.fold setCell grid
我发布了一个更新。不过我还没有测试过。你认为呢？
Seq.last
如果序列为空，就会爆炸。@ScottNimrod-是的，如果序列为非空，你的方法会起作用。
Seq.last
如果序列为空，就会爆炸，但是
Seq.tryLast
不会。我发布了一个更新。不过我还没有测试过。你认为呢？
Seq.last
如果序列为空，就会爆炸。@ScottNimrod-是的，如果序列为非空，你的方法会起作用。
Seq.last
如果序列为空，就会爆炸，但是
Seq.tryLast
不会。你确定不想改为折叠吗
x |>Seq.map f |>Seq.map g |>Seq.last
与
x |>Seq.last |>f |>g
相同，只要
f
和
g
没有副作用。@kvb-老实说，我还不明白。对我来说，这看起来很神秘。折叠需要序列中的一个元素加上一些状态，并应用一个函数来获取更新后的状态，以便与序列中的下一个元素一起使用。否则，如果
setCell
输出一个修改后的map，但没有任何副作用，那么除了上次调用所做的修改外，您将丢弃所有修改。
fold
基本等同于基本的
foreach
循环。它只是作为递归在内部实现的。这意味着您不需要在循环外修改可变状态，而是从上一个循环中获取状态作为输入，并为下一次迭代生成新状态。您确定不需要折叠吗
x |>Seq.map f |>Seq.map g |>Seq.last
与
x |>Seq.last |>f |>g
相同，只要
f
和
g
没有副作用。@kvb-老实说，我还不明白。对我来说，这看起来很神秘。折叠需要序列中的一个元素加上一些状态，并应用一个函数来获取更新后的状态，以便与序列中的下一个元素一起使用。否则，如果
setCell
输出一个修改后的map，但没有任何副作用，那么除了上次调用所做的修改外，您将丢弃所有修改。
fold
基本等同于基本的
foreach
循环。它只是作为递归在内部实现的。这意味着您将从上一个循环中获取状态作为输入，并为下一次迭代生成新状态，而不是在循环外修改的可变状态。