Operation substitution in OCaml - ocaml

Question

I have one task in hand that I am 90% done with it but just don't quite know how to finish it. So the task is as follows : " Write a non-recursive function which takes a function, and two lists as an input, and returns a third list which contains the result of the function applied on all possible pairs of elements from both input lists." So I have to get it as below.
# 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]
My struggle is that I don't know how to make a function substitution. Here is my code.
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;;
But I would like that in part (x*y) the multiplication be given as an argument before the lists.
Thank you for your help in advance.

Answer 1

Most of the journey has already been made! Well done!
As you can see by using the fold_left function, in OCaml (as in other functional languages) you can pass functions as arguments (and even return them), which is why you can provide fold_left with an accumulation function. Here is your code:
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;;
Even if the code is very good, let's rephrase it a bit to see it more clearly!
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
As you may have realised: (fun acc x -> process_list_2 acc x) is, in fact, identical to process_list_2 so, let's rephase one more time:
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
But hey, we want to generalise cart_fun in ordrer to have, instead of cart_fun list1 list2, we want cart_fun modifier list1 list2, where modifier is just a function... So, no problem, let's changing this part of the code:
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
And voila! As you can see, there wasn't much modification required. Just keep in mind that in OCaml, you can consider that a variable will contain a function; which is pretty cool!
Btw, the "general behaviour" that you want to capture looks a lot like what we call "a comprehension" (like in Python and Haskell). And since OCaml 4.10, there is a function in list module which allow you to write easily comprehension : List.concat_map val concat_map : ('a -> 'b list) -> 'a list -> 'b list which has the same effect than mapping over a list of 'a, producing a list of list of b and flatten the list into a list of b.
So you can see your cartesian product as :
let cart_fun modifier list1 list2 =
List.concat_map (fun x ->
List.concat_map (fun y ->
[modifier x y]
) list2
) list1
But as you can see... it's not much more readable than before! Fortunately, in addition to passing functions as arguments, OCaml also allows you to describe your own operators. For example, here we could describe an operator to simplify the chaining of concat_map which we would randomely call... >>= :
let (>>=) list f = List.concat_map f list
let cart_fun modifier list1 list2 =
list1 >>= fun x ->
list2 >>= fun y -> [modifier x y]
Awesome, can we go deeper in the readability ? Of course, since OCaml 4.08, you can define let operators. So defining your own let with a suffix. For example, here, let's define let* (which will be exactly the same of >>=)
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` *)
nice no?
And now, we can rewrite our example:
let cart_fun modifier list1 list2 =
let* x = list1 in
let* y = list2 in
[modifier x y]
And voila ! Even:
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
Is "more direct" I think it is nice to see how OCaml is expressive!