Oops, I didn't do a group-reply... so in case anyone is interested in what
I ended up with:

---------- Forwarded message ----------
From: Anthony Tavener <anthony.tavener@gmail.com>
Date: Wed, Nov 2, 2011 at 2:50 PM
Subject: Re: [Caml-list] Nested module exposing type from parent?
To: Vincent Aravantinos <vincent.aravantinos@gmail.com>


Actually, better than I initially thought...

I keep this as I have them defined already, except as you said: include
instead of open.

  module Vec = struct
    module Type = struct
      type t = { x: int; y: int }
    end
    include Type
    let make x y = {x;y}
    let add a b = {x=a.x+b.x; y=a.y+b.y}
  end

Before, I had instead of the include:
  type t = Type.t
  open Type

Which worked, but then the type used everywhere was Vec.Type.t

Thanks again! Simple and effective, and I was looking in all the wrong
places. :)

On Wed, Nov 2, 2011 at 2:36 PM, Anthony Tavener
<anthony.tavener@gmail.com>wrote:

> Thank-you Vincent!
>
> Though this requires a home for the "source type" module, at least the
> types come out right in the end. Thanks!
>
> And this led me to read specifically about include to understand what it
> really does. :)
>
>
> On Wed, Nov 2, 2011 at 2:19 PM, Vincent Aravantinos <
> vincent.aravantinos@gmail.com> wrote:
>
>> **
>> Using "include" instead of "open" would work, ie. turning your example
>> into:
>>
>> module Vec_main = 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}
>> end
>>
>> module Vec = struct
>>   include Vec_main
>>   module Type = struct
>>     include Vec_main
>>     ...
>>   end
>> end
>>
>> Then:
>> # let n = Vec.make 2 5;;
>> val n : Vec.t = {Vec.x = 2; Vec.y = 5}
>> # open Vec.Type;;
>> # let m = {x=1;y=2};;
>> val m : Vec.Type.t = {x = 1; y = 2}
>> # Vec.add m n;;
>> - : Vec.t = {Vec.x = 3; Vec.y = 7}
>>
>> Cheers
>>
>> --
>> Vincent Aravantinos - Postdoctoral Fellow, Concordia University, Hardware Verification Group
>>
>>
>> On 11/02/2011 03:41 PM, Anthony Tavener wrote:
>>
>> 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
>>
>>
>>
>