OCaml 中的操作替换

如何解决OCaml 中的操作替换

我手头有一项任务，我已经完成了 90%，但只是不知道如何完成它。所以任务如下： " 编写一个非递归函数，它接受一个函数和两个列表作为输入，并返回第三个列表，该列表包含应用于所有可能的元素对的函数的结果输入列表。” 所以我必须得到它如下。

# cart_fun ( * ) [1;2;2;6;3;9;1] [2;3];; -: int list = [2; 3; 4; 6; 4; 6; 12; 18; 6; 9; 18; 27; 2; 3]

我的挣扎是我不知道如何进行函数替换。这是我的代码。

let cart_fun list1 list2 =
  let res = List.fold_left (fun acc x -> List.fold_left (fun acc y -> (x * y) :: acc) acc list2) [] list1
  in List.rev res;;

但我希望 (x*y) 部分中的乘法作为列表之前的参数给出。

提前感谢您的帮助。

解决方法

大部分旅程已经完成！做得好！ 正如您通过使用 fold_left 函数所看到的，在 OCaml（如在其他函数式语言中）中，您可以将函数作为参数传递（甚至返回它们），这就是为什么您可以为 fold_left 提供累积功能。这是您的代码：

let cart_fun list1 list2 =
  let res = List.fold_left (fun acc x -> 
      List.fold_left (fun acc y -> (x * y) :: acc) acc list2) 
   [] list1
  in List.rev res;;

即使代码非常好，为了看得更清楚，还是稍微改写一下吧！

let cart_fun list1 list2 = 
   let process_list_2 fst_acc = 
        List.fold_left 
           (fun snd_acc y -> (x * y) :: snd_acc) 
           fst_acc 
           list2 
   in 
   let result = List.fold_left (fun acc x -> process_list_2 acc x) [] list1 in 
   List.rev result

您可能已经意识到：(fun acc x -> process_list_2 acc x) 实际上与 process_list_2 相同，因此，让我们再重新调整一次：

let cart_fun list1 list2 = 
   let process_list_2 fst_acc = 
        List.fold_left 
           (fun snd_acc y -> (x * y) :: snd_acc) 
           fst_acc 
           list2 
   in 
   let result = List.fold_left process_list_2 [] list1 in 
   List.rev result

但是，嘿，我们想要概括 cart_fun 以便拥有，而不是 cart_fun list1 list2，我们想要 cart_fun modifier list1 list2，其中 modifier 只是一个函数......所以，没问题，我们改一下这部分代码：

let cart_fun modifier list1 list2 = 
   let process_list_2 fst_acc = 
        List.fold_left 
           (fun snd_acc y -> (modifier x y) :: snd_acc) 
           fst_acc 
           list2 
   in 
   let result = List.fold_left process_list_2 [] list1 in 
   List.rev result

瞧！如您所见，不需要太多修改。请记住，在 OCaml 中，您可以认为变量将包含一个函数；这很酷！

顺便说一句，您想要捕获的“一般行为”看起来很像我们所说的“理解”（例如在 Python 和 Haskell 中）。从 OCaml 4.10 开始， list 模块中有一个函数可以让您轻松编写理解：List.concat_map val concat_map : ('a -> 'b list) -> 'a list -> 'b list 与映射 'a 的列表具有相同的效果，生成列表的列表b 并将列表展平为 b 的列表。 所以你可以看到你的笛卡尔积为：

let cart_fun modifier list1 list2 =
    List.concat_map (fun x ->
       List.concat_map (fun y -> 
           [modifier x y]
       ) list2 
    ) list1

但是正如你所看到的......它并不比以前更具可读性！幸运的是，除了将函数作为参数传递之外，OCaml 还允许您描述自己的运算符。例如，在这里我们可以描述一个运算符来简化我们随机调用的 concat_map 的链接... >>= :

let (>>=) list f = List.concat_map f list

let cart_fun modifier list1 list2 = 
   list1 >>= fun x ->
   list2 >>= fun y -> [modifier x y]

太棒了，我们可以更深入地了解可读性吗？当然，从 OCaml 4.08 开始，您可以定义 let 运算符。所以用后缀定义你自己的 let。例如，在这里，让我们定义 let*（与 >>= 完全相同）

let (let*) list f = List.concat_map f list
(* So `let* x = l in g x` is the same of `l >>= fun x -> g x` *)

好吗？

现在，我们可以重写我们的例子：

let cart_fun modifier list1 list2 = 
   let* x = list1 in 
   let* y = list2 in 
   [modifier x y]

瞧！甚至：

let cart_fun modifier list1 list2 = 
   let process_list_2 fst_acc = 
        List.fold_left 
           (fun snd_acc y -> (modifier x y) :: snd_acc) 
           fst_acc 
           list2 
   in 
   let result = List.fold_left process_list_2 [] list1 in 
   List.rev result

“更直接”我认为很高兴看到 OCaml 的表现力！