[Caml-list] Type annotations [Was: Are record types generative?]

[Oleg <oleg@okmij.org>]

# Perhaps the subthread on type annotations should get its own
# subject...

> On Tue, Jan 23, 2018 at 6:14 PM, Hendrik Boom wrote:
>
>     I'm starting to think that the ability to write OCaml programs without
>     mentioning the types is a drawback in the language, because it makes
>     programs hard to understand.

I strongly recommend students to type-annotate all functions they
write. In fact, they should start writing code by writing out its
type. If they don't have a good idea what interface the function
should have, it's very likely that they haven't really thought the
problem through. In that case, they should think more about what it is
they want to do, rather than jumping into writing code they have only
a vaguest idea of.

I follow the same advice myself. For example, suppose I want to write 
an accumulating map, which maps elements of a list and accumulates
something along the way (this function proved very handy, at least in
MetaOCaml implementation). The first this is to decide on the
interface:

let rec map_accum : 
  ('accum -> 'a -> 'b * 'accum) -> 'accum -> 'a list -> 'b list * 'accum = 

after which the code is easy to write

 fun f acc -> function
    | []   -> ([],acc)
    | h::t -> 
        let (h,acc) = f acc h in
        let (t,acc) = map_accum f acc t in
        (h::t, acc)

One clear benefit of the explicit annotation is that the type errors
become much more meaningful and precise (which is especially important
for students).

Granted, sometimes the type of some complicated callback could be
too complicated to spell out (which is often the indication that one
should give it a name). In that case, the underscore is handy:

let rec map_accum : 
  _ -> 'accum -> 'a list -> 'b list * 'accum = ...

In short, if we know that a function is to take three arguments and
return an int, why not to write it down. It also helps reading the
code later on (without clicking on various identifiers: I can read much
faster than I can click).