CODEWITHSUNDEEP
ocaml
Ross Rogers
Ross Rogers

Reputation: 24260

How do you read OCaml function typing output in your mental dialog?

For [1]:

# let make pair int (x:int) (y:int) = x,y ;;
val make_pair_int : int -> int -> int * int = <fun>

How do you read the typing information output? In other languages, I find being able to construct a cogent, English sentence out of the syntax or the printouts to be critical in understanding what's going on. What's the sentence for the above OCaml statement?

Could someone diagram out the printout so as to correlate the typing information back into English? Like:

val make_pair_int : int -> int -> int * int = <fun>
      |              |   |  |   |  \_____/  \__/
      |              |   |  |   |     |       ` is a function
      |              |   |  |   |     ` a tuple of integers
      |              |   |  |   `
      |              |   |  `
      |              |   `
      |              `
      ` symbol make_pair_int is bound to

Upvotes: 3

Views: 435

Answers (2)

Francois G
Francois G

Reputation: 11985

This is just the curried version of your function. The reading of such a function depends on how comfortable you are with curried notation for functions.

The gist is to consider that taking two arguments is a completely different notion from taking a pair of arguments in the sense that the pair makes a reference to a specific type constructor (what is hidden under the * and , symbols in your ocaml snippet).

What do you do if you do not want to make a reference to a pairing (or tupling, if you want an arbitrary array of arguments) construct ? The curried answer to that question is the one that makes use of higher-order functions:

val make_pair_int : int -> int -> int * int = <fun>
      |              |   |  |   |  \_____/  \__/
      |              |   |  |   |     |       ` and all that is a higher-order function
      |              |   |  |   |     ` a pair of integers
      |              |   |  |   `and returns
      |              |   |  `a function that takes an integer as an argument
      |              |   `and returns
      |              ` something that takes an integer as an argument 
      ` symbol make_pair_int is bound to

With the implicit convention that this curried interpretation (and the notation that comes with it) is the admitted way of thinking of a function taking several arguments, you can just count the number of arrows in the type, and consider those before the last one as "the arguments" of your function.

Upvotes: 3

LiKao
LiKao

Reputation: 10658

I guess it is highly subjective and depends on the use of the function. Usually I try to read this as the uncurried version of the function and then read this in my mind. However if I actually use this function to construct closures I might read it as something different.

So in this case, depending on the context I use this function i would read it as:

"function from int and int to tuple of integers"

In other cases the same might become:

"function from int to function from int to tuple of integers"

I guess the ability to switch between the two representations of the same function offers a lot of flexibility in the use of the function later.

Upvotes: 2

Related Questions