Version française
Home     About     Download     Resources     Contact us    

This site is updated infrequently. For up-to-date information, please visit the new OCaml website at

Browse thread
[Caml-list] functors with style?
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: William Harold Newman <william.newman@a...>
Subject: [Caml-list] functors with style?
I have some questions about functorial programming style.

First, a general question. I've used the ocaml-3.02 source as an
example when I couldn't guess something about normal style, but it
doesn't seem to use functors much. Since it looks like a great deal of
work has been done on functors, I expect that there are applications
which depend on them. Is there any publicly available Ocaml code which
someone could recommend as an example of good functorial style?

Then, some specific questions about this toy confidence_interval.mli:

module type ORDERING =
    type t
    val are_ordered: t -> t -> bool

module F:
functor (Ordering: ORDERING) ->
    type t
    val new_t: Ordering.t -> Ordering.t -> t
    val lo: t -> Ordering.t
    val hi: t -> Ordering.t

module Int:
      type t
      val new_t: int -> int -> t
      val lo: t -> int
      val hi: t -> int

module Float:
      type t
      val new_t: float -> float -> t
      val lo: t -> float

As you can see from this example, my impulse is to give names to
modules like $Confidence_interval.Int$ and $Confidence_interval.Float$
(which are defined in as $F(Int_ordering)$ and
$F(Float_ordering)$), but that leads to annoyances:
 * It's annoying to have to specify the redundant signatures for
   $Int_confidence_interval$ and $Float_confidence_interval$.
   They're exactly parallel by intent, so I'd like to 
   construct the signatures with a functor-like thing, but from the
   syntax in section 6.10 of the manual, I'm pretty sure that I can't.
 * I can't find a way to use the $F$ to define anything
   in the top level namespace, e.g. $Int_confidence_interval$
   or $My_custom_type_confidence_interval$, so I end up 
   with  $Confidence_interval.Int$ here and then, when I use $F$
   later for other things, $My_custom_type.Confidence_interval$,
   and the slightly-baroque and not-at-all-parallel names are annoying.

It occurs to me that these annoyances could be avoided by keeping the
functor-constructed modules anonymous, using explicit functor
expressions (e.g. $Confidence_interval.F(Int_order)$ and
$Confidence_interval.F(My_custom_type)$) in any code which uses the
modules. Would that be a good way to do it? Or is there some other
good way?

If I did use explicit functor expressions everywhere, it'd be readable
enough: if my intent is make the things exactly parallel, then using
the explicit functor expressions everywhere would make that obvious,
so I'd be happy. But because my previous closest approach to functors
was using templates in g++, I'm predisposed to worry about the
compiler emitting multiple copies of the functor expansion if I don't
give the functor expansion a home in a particular file. Is that an
issue in Ocaml?

William Harold Newman <>
"Furious activity is no substitute for understanding." -- H. H. Williams
PGP key fingerprint 85 CE 1C BA 79 8D 51 8C  B9 25 FB EE E0 C3 E5 7C
Bug reports:  FAQ:
To unsubscribe, mail  Archives: