I've been struggling with this occasionally...

I'm using nested modules to "open" access to select features of a module.
My problem is I can't find a way to *expose* types in the parent module
through such nested modules.

A simplified example of what I'm looking at:

  module Vec = struct

    type t = { x: int; y: int }
    let make x y = {x;y}
    let add a b = {x=a.x+b.x; y=a.y+b.y}

    module Type =
      (* something which has type t = Vec.t,
       * with exposed structure when "open"ed.
       * Also note that Vec is not really an
       * explicit module like this; instead it
       * is implemented in vec.ml *)
  end

Example usage...

  let n = Vec.make 2 5
  open Vec.Type
  let m = {x=1;y=2}
  Vec.add m n


To date, I've defined the type in the Type submodule, which is then used by
the parent module. The unsatisfactory quality of this is that Vec.Type.t is
the "true" type. Ideally the concrete type would live at Vec.t, with "open
Vec.Type" bringing the fields of the type into scope.

As background, here are examples of opening different features of the Vec
module:

  let c = Vec.add a b

  open Vec.Prefixed
  let c = vadd a b

  open Vec.Ops
  let c = a +| b

  open Vec.Type
  let c = Vec.add a {x;y;z=0.}

Apologies if this is really beginner-list material. It's minor, but has
been bugging me.
Thank-you for looking,

 Tony