Function with unknown value works. OCaml

Question

I cant understand some things in my code. It is program in OCaml which generates all distinct pairs from elements in list. Here's my code:

let rec tmp f list x =
    match list with
    | [] -> x
    | h :: t -> f h (tmp f t x);;
    (*          ^ ^ (^        ) (1) *)

let rec distinctpairs lst = 
    match lst with
    | [] -> []
    | h :: t -> tmp ( fun x lt -> (h,x)::lt) t (distinctpairs t);;
    (*                    ^          ^ (2)                    *)

Do function tmp returns three values ?
How i can give an argument to func, when i dont know what is x?

When i assume that tmp return three values, that why when I giving as arg to tmp the ( fun x lt -> (h,x)::lt) argument, and it works?

Jackson Tale Jackson Tale · Accepted Answer · 2013-12-11T10:20:30

1. Do function tmp returns three values ?

let rec tmp f list x =
    match list with
    | [] -> x
    | h :: t -> f h (tmp f t x);;

The simple answer to this question is no.

f h (tmp f t x) is not three value, instead, it is a function execution/application on f.

2. How i can give an argument to func, when i dont know what is x?

let rec distinctpairs lst = 
    match lst with
    | [] -> []
    | h :: t -> tmp ( fun x lt -> (h,x)::lt) t (distinctpairs t);;

The truth here is you know x. x is defined as a parameter of the anonymous function fun x lt -> (h, x)::lt.

When i assume that tmp return three values, that why when I giving as arg to tmp the ( fun x lt -> (h,x)::lt) argument, and it works?

First of all, when ocaml sees tmp f list x, ocaml does not know anything but tmp accepts 3 parameters.

When ocaml reaches | [] -> x, it knows whatever type x is, the tmp will return the same type as x.

When ocaml reaches | h::t -> f h (tmp f t x), it knows f must be a function and f will have 2 parameters: one with type of h and one with type of x

Then in your distinctpairs function, ( fun x lt -> (h,x)::lt) is an anonymous function which really matches the prediction above.

A better way to write the two functions:

let rec tmp f x = function
    | [] -> []
    | h :: t -> f h (tmp f x t)

let rec distinctpairs = function
    | [] -> []
    | h :: t -> tmp (fun x lt -> (h,x)::lt) (distinctpairs t) t

I also suggest you to read Real World Ocaml book. It is the newest and most comprehensive book on OCaml and it is good.

When you try to enter functional programming world, there is no shortcut. It is not like you learn Spanish as an English speaker. It is more like learning Chinese/Japanese as an English speaker.

The whole idea is quite different from Java or C# or C, and of course, much better than Java (my personal feeling). So I suggest you to learn from ground.

Function with unknown value works. OCaml

1 Answers