Hello,
I would like to define a parameterized module inside an object by the type
of this object.


I have two module interlocked :

(* Parameters*)
module type A = sig
        type agent
        type intern_agent = { i : agent}
        val create : agent -> intern_agent
end

module type E = sig
        type event
end



module  type StateType = sig

  type agent
  type event

  type  state_t = {
    mutable name : string;
    mutable parentstate  :  state_t option;
  }
end


module State (A : A) (E : E) = struct

        type agent = A.agent
        type event = E.event
    type  state_t = {
            mutable name : string;
             mutable parentstate  :  state_t option;
    }


    (*...*)
end



module Agent (S : StateType) =
        struct
          type agent = S.agent
          type event = S.event
          type state_t = S.state_t

      type  agent_t = {
          mutable agent      : agent ;
      }

      let create a1   = {
          agent          = a1;
      }
end


(* An implementation of E*)
type event1 = Event1 | Event2;;
module E = struct type event = event1 end;;




What I would like to do is something like that (which is syntacticly
incorrect but represents what I would like to do) :


class  character = object (self :'self)
 val mutable position        = (0,0)
 val agent                         =
                let A = (module Ag  = struct
                                type agent = 'self
                                type intern_agent = { i : agent}
                                let create a = { i = a }
                              end)
                     in
                let Ag = (module Agent(State(A)(E)) ) in
                Ag.create self

 method getPosition          = position

end;;



How can I write this to be able to define a value which is an Agent
parametrized by itself ?

Thank you,

-- 
Pierre-Alexandre Voye
---------------------
https://twitter.com/#!/ontologiae/
http://linuxfr.org/users/montaigne