[Caml-list] functors with style?

[William Harold Newman <william.newman@airmail.net>]

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 =
  sig
    type t
    val are_ordered: t -> t -> bool
  end

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

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

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

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 confidence_interval.ml 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 <william.newman@airmail.net>
"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: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr