Ocaml Tail recursive version - ocaml

Question

I have a function called zip_with_2_fs. I am trying to make it tail recursive (zip_with_2_fs_tr) but I don't really understand what I am doing. I am new to Ocaml and would like to develop a deeper understanding of tail recursion and helper functions.
let rec zip_with_2_fs fx fy xs ys =
match (xs, ys) with
| ([], []) -> []
| ([], _) -> []
| (_, []) -> []
| (xh::xt, yh::yt) -> (fx xh, fy yh)::zip_with_2_fs fx fy xt yt;;
How would I go about fixing this?
let zip_with_2_fs_tr fx fy xs ys =
let rec helper fxx fy xss yss =
match (xs, ys) with
| ([], []) -> []
| ([], _) -> []
| (_, []) -> []
| (xh::xt, yh::yt) -> (fx xh, fy yh)::helper fx fy xt yt
in helper fx fy xs ys;;

Answer 1

The expression, (fx xh, fy yh)::helper fx fy xt yt is not tail recursive, because in order to reduce it to a value you need the result of the recursive call. E.g., let's rewrite it in a more verbose way, just to give names to things (it is easier to speak about things when they have names),
let head = (fx xh, fy yh) in
let tail = helper fx fy xt yt in (* recursive call *)
let result = head :: tail in
result
So here, we are making a recursive call and the result of the current call is not determined until this call returns, therefore our calls accumulate (as the recursive call will make its own call and wait until the result is ready, and so on) and we have precious stack space being spent to store all those intermediate results.
So the trick is that a value returned by the recursive call shall be the result of the calling function. The concept of a tail call is actually more general that the tail-recursive call. As any call whose result becomes the result of a caller is called a tail call and could be made without expending the stack space, e.g., speaking C,
int bar(int x) {return x + 1; }
int foo(int x) {return bar(x+1);}
Here we have a tail-call from foo to bar and the compiler may easily implement it with just a jump to bar without having to allocate a new stack frame or taking care of passing the value retuned from bar.
Back to OCaml. So we need to make sure that the value returned by our recursive function is the value returned by the recursive call. But there is no free lunch here, since we need to have some space where we will accumulate our intermediate result. In the non-tail recursive function version it was the program stack. Instead of the program stack, we can explicitly create a value and accumulate values in it during our recursive calls, e.g.,
let zip_with_f_fs fx fy xs ys =
let rec loop acc xs ys = match xs, ys with
| [],[] -> List.rev acc
| x::xs,y::ys -> loop ((fx x, fy y)::acc) xs ys
| _ -> failwith "uneven lists" in
loop [] xs ys
Now you can see that we have a recursive call to loop
| x::xs,y::ys -> loop ((fx x, fy y)::acc) xs ys
that is in the tail position, and we store our result in the first parameter called acc and once we reach the end of both lists, we reverse it (because we were pretending it, in fact acc was our stack) to get the values in the right order.