Question

I have an ocaml type :

type t = A | B |  ...

and a function to print things about that type :

let pp_t fmt x = match x with 
  | A -> Format.fprintf fmt "some nice explanations about A"
  | B -> Format.fprintf fmt "some nice explanations about B"
  | ...

How could I write a function to print all the explanations ? Something equivalent to :

let pp_all_t fmt = 
   Format.fprintf fmt A;
   Format.fprintf fmt B;
   ...

but that would warn me if I forget to add a new constructor.
It would be even better to have something that automatically build that function,
because my problem is that t is quiet big and changes a lot.

I can’t imagine how I can “iterate” on the type constructors, but maybe there is a trick…

EDIT: What I finally did is :

type t = A | B |  ... | Z
let first_t = A
let next_t = function A -> B | B -> C | ... | Z -> raise Not_found
let pp_all_t fmt = 
  let rec pp x = pp_t fmt x ; try let x = next_t x in pp x with Not_found -> ()
  in pp first_t

so when I update t, the compiler warns me that I have to update pp_t and next_t, and pp_all_t doesn’t have to change.
Thanks to you all for the advices.

Answer 1

To solve your problem for a complicated and evolving type, in practice I would probably write an OCaml program that generates the code from a file containing a list of the values and the associated information.

However, if you had a function incr_t : t -> t that incremented a value of type t, and if you let the first and last values of t stay fixed, you could write the following:

let pp_all_t fmt =
    let rec loop v =
        pp_t fmt v;
        if v < Last_t then loop (incr_t v)
     in
         loop First_t

You can’t have a general polymorphic incr_t in OCaml, because it only makes sense for types whose constructors are nullary (take no values). But you can write your own incr_t for any given type.

This kind of thing is handled quite nicely in Haskell. Basically, the compiler will write some number of functions for you when the definitions are pretty obvious. There is a similar project for OCaml called deriving. I’ve never used it, but it does seem to handle the problem of enumerating values.

Since you say you want a “trick”, if you don’t mind using the unsafe part of OCaml (which I personally do mind), you can write incr_t as follows:

let incr_t (v: t) : t =
    (* Please don't use this trick in real code :-) !  See discussion below.
     *)
    if t < Last_t then
        Obj.magic (Obj.magic v + 1)
    else
        failwith "incr_t: argument out of range"

I try to avoid this kind of code if at all possible, it’s too dangerous. For example, it will produce nonsense values if the type t gets constructors that take values. Really it’s “an accident waiting to happen”.