Functional programming OCaml：左折，右折转换

在,， 我们有：

val fold_左：（'a->'b->'a）->'a->'b list->'a

List.fold_left fa[b1；…；bn]是f（…（f（fab1）b2）…）bn

val fold_right:（'a->'b->'b）->'a list->'b->'b

List.fold_right f[a1；…；a]b是f a1（f a2（…（f an b）…）

。不是尾部递归

问题是如何使用List.fold\u right函数实现“fold\u left”函数。 这是我在互联网上找到的答案：

let rec my_fold_left f a l = List.fold_right (fun x g a -> g (f a x)) l (fun x -> x) a;;

val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a

第一次，我写道：

let rec my_fold_left_old f a l = List.fold_right (fun x a -> f a x) l a;;

val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a

类型检查是正确的，但是my_fold_left_old是错误的，因为它将列表从最后一个元素扫描到第一个元素

---

谁能解释一下上面的函数my\u fold\u left，List.fold\u right只能有3个参数，但是上面的my\u fold\u left有4个参数吗？

这是个问题。本质上，

List.fold_right

的类型为

（'a->'b->'b）->'a List->'b

，此定义将该操作与

'b

的函数类型一起使用

您可以看到这如何为

列表生成“四个参数”。如果您将
'c->'d
替换为
'b
，跳过冗余参数，请向右折叠：

('a -> 'c -> 'd -> ('c -> 'd)) -> 'a list -> 'c -> 'd

因此，
List.fold_right
折叠列表以生成函数，该函数应用于一个参数以生成最终结果。为了更清楚地说明这一点，让我们用一个命名的临时文件重写它：

 let foldl f init list =
  let fold_result =
    List.fold_right
      (fun elt g acc -> g (f acc elt))
      list
      (fun x -> x) in
  fold_result init