It frequently happens that I have a module/functor A parameterized by
module B, but B depends on types that are part of A.  Those types of A in
turn depend on the types of B.  Wow, I've confused myself already.  Let me
try to make this clearer:

    let A.avalue = ... B.bvalue ...
    val B.bvalue : ... A.atype ...
    type A.atype = ... B.btype ...

This results in the following kind of double-functor, one functor for the
types and the second internal functor for the values:

module A = struct

  module Types (B_types : sig type btype end) = struct

    type atype = ... B_types.btype ...

    module Values (B_values : sig val bvalue : ... atype ... end) = struct

      let avalue = ... B_values.bvalue ...

    end
  end
end

module B = struct

  type btype = ...

  module A_types = A.Types (struct type btype = B.btype end)

  let bvalue = ...

  module A_values = A_types.Values (struct let bvalue = B.bvalue end)

  let _ = ... A_values.avalue ...

end

So, my questions are:

(1) is this a normal way of structuring this kind of thing?  I know I could
    use polymorphic types instead of trying to make it work in the module
    system, but I like the idea that all my types are made explicit.

(2) do I pay a run-time cost for functor applications that only contain
    types?  In other words, does A_values.avalue suffer a double
    indirection since it is buried two functors deep?  Or do you only pay
    the indirection cost for values that are passed across functorial
    boundaries?


__________________________________________________
Do You Yahoo!?
Yahoo! - Official partner of 2002 FIFA World Cup
http://fifaworldcup.yahoo.com
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners