Ocaml中的递归

Question

I'm new to Ocaml and i'm trying to write a recursion function.

The function take a list of pairs and return a pair of lists, for example

[(1, 4); (2, 3); (5, 9); (6, 10)]) -> ([1; 2; 5; 6], [4; 3; 9; 10])

But the compiler say that: Error: This expression has type 'a list * 'b list but an expression was expected of type 'a list

in the line (unzip (List.tl m))

Can someone explain why I have this error please? And is there anyway to fix this? Thank you very much!

let rec unzip m =
    if List.length m = 0 then
       ([], [])
    else
       ((fst (List.hd m)) :: (unzip (List.tl m)), (snd (List.hd m)) :: (unzip (List.tl m)))
in 
    unzip m;; 

Answer 1

For any recursion, you have to note that the output type will be always the same.

Let's see your unzip function.

[(1, 4); (2, 3); (5, 9); (6, 10)]) -> ([1; 2; 5; 6], [4; 3; 9; 10])

Simply say, the return type of unzip is def a pair (tuple) , and each element is a list, correct?

---

Then let's see your code

let rec unzip m =
    if List.length m = 0 then
       ([], [])
    else
       ((fst (List.hd m)) :: (unzip (List.tl m)), (snd (List.hd m)) :: (unzip (List.tl m)))
in 
    unzip m;;

You have two branches. First branch is returning ([], []) . Ok, in terms of return type, it is correct as it is a pair with two empty lists and matches the return type described above.

---

The second branch

((fst (List.hd m)) :: (unzip (List.tl m)), (snd (List.hd m)) :: (unzip (List.tl m)))

is it correct?

It is a pair with two elements, no problem, then let's see the first element:

(fst (List.hd m)) :: (unzip (List.tl m))

You are trying to add (fst (List.hd m)) to the head of (unzip (List.tl m)) .

But you can only add something to a list by using :: , so ocaml supposes (unzip (List.tl m)) is a list, right?

But it is a unzip function application, apparently described in the beginning, your unzip is not returning a list, but a pair (tuple).

So ocaml doesn't understand and thus complain.

---

The above is just to answer your question about the type problem. But your code has more problems.

1. incorrect use of in

Suppose you have a function f1 . You can image it as the mother function, which means it can be used directly. Also in f1 , you can declare another function or variable (or more formally, a binding). Only when you declare a binding inside a function, you use let...in... . If you only have the mother function, you don't use in , because in where ?

In your unzip , you only have one function or binding which is unzip itself and it is in top level. So in is not necessary.

2. incorrect logic of recursion

I don't know how to explain to you about recursion here, as it needs you to read more and practise more.

But the correct code in your idea is

let rec unzip = function
  | [] -> ([], [])
  | (x,y)::tl -> 
    let l1, l2 = unzip tl in
    x::l1, y::l2

If you are chasing for better or a tail-recursive version, here it is:

let unzip l = 
  let rec unzip_aux (l1,l2) = function
    | [] -> List.rev l1, List.rev l2
    | (x,y)::tl -> unzip_aux (x::l1, y::l2) tl
  in 
  unzip_aux ([],[]) l

Answer 2

The error comes from the fact that (unzip ...) returns a pair of lists ( 'a list * 'b list ), which you try to manipulate as a list when you write (fst ..) :: (unzip ...) .

This would all be written much more nicely if you used pattern-matching. Skeleton:

let rec unzip = function
  | [] -> ...
  | (x,y) :: rest ->
    let (xs, ys) = unzip rest in ...