module Make :
  functor
    (TV : sig
            type 'a combined
            type 'a t = 'a Luaiolib.t
            val makemap :
              ('a combined, 'b, 'b) Luavalue.ep ->
              ('b -> string -> 'a t) -> ('a t, 'b, 'b) Luavalue.ep
          end) ->
    sig
      type 'a userdata' = 'a TV.combined
      module M :
        functor
          (C : sig
                 module V :
                   sig
                     type 'a userdata' = 'a userdata'
                     type srcloc
                     type initstate
                     type value =
                         Nil
                       | Number of float
                       | String of string
                       | Function of srcloc * func
                       | Userdata of userdata
                       | Table of table
                     and func = value list -> value list
                     and table = (value, value) Luahash.t
                     and userdata = value userdata'
                     and state = {
                       globals : table;
                       fallbacks : (string, value) Hashtbl.t;
                       mutable callstack : activation list;
                       mutable currentloc : Srcmap.location option;
                       startup : initstate;
                     }
                     and activation = srcloc * Srcmap.location option
                     val caml_func : func -> value
                     val lua_func :
                       file:string -> linedefined:int -> func -> value
                     val srcloc : file:string -> linedefined:int -> srcloc
                     val eq : value -> value -> bool
                     val to_string : value -> string
                     val activation_strings :
                       state -> activation -> string list
                     type objname =
                         Fallback of string
                       | Global of string
                       | Element of string * value
                     val objname : state -> value -> objname option
                     val state : unit -> state
                     val at_init : state -> string list -> unit
                     val initcode : state -> (string -> unit) -> unit
                     module Table :
                       sig
                         val create : int -> table
                         val find : table -> key:value -> value
                         val bind : table -> key:value -> data:value -> unit
                         val of_list : (string * value) list -> table
                       end
                     exception Projection of value * string
                     val projection : value -> string -> 'a
                     type ('a, 'b, 'c) ep =
                       ('a, 'b, 'c) Luavalue.synonym_for_ep = {
                       embed : 'a -> 'b;
                       project : 'b -> 'a;
                       is : 'c -> bool;
                     }
                     type 'a map = ('a, value, value) ep
                     type 'a mapf
                     val float : float map
                     val int : int map
                     val bool : bool map
                     val string : string map
                     val userdata : userdata map
                     val unit : unit map
                     val option : 'a map -> 'a option map
                     val default : 'a -> 'a map -> 'a map
                     val list : 'a map -> 'a list map
                     val optlist : 'a map -> 'a list map
                     val value : value map
                     val table : table map
                     val record : 'a map -> (string * 'a) list map
                     val enum : string -> (string * 'a) list -> 'a map
                     val ( --> ) : 'a map -> 'b map -> ('a -> 'b) map
                     val ( **-> ) : 'a map -> 'b mapf -> ('a -> 'b) mapf
                     val result : 'a map -> 'a mapf
                     val resultvs : value list mapf
                     val resultpair : 'a map -> 'b map -> ('a * 'b) mapf
                     val dots_arrow :
                       'a map -> 'b map -> ('a list -> 'b) mapf
                     val results :
                       ('a -> value list) -> (value list -> 'a) -> 'a mapf
                     val func : 'a mapf -> 'a map
                     val closure : 'a mapf -> 'a map
                     val efunc : 'a mapf -> 'a -> value
                     type alt
                     val alt : 'a mapf -> 'a -> alt
                     val choose : alt list -> value
                     val ( <|> ) : 'a map -> 'a map -> 'a map
                     val ( <@ ) : 'a map -> ('a -> 'b) -> 'b map
                   end
                 val error : string -> 'a
                 val getglobal : V.state -> V.value -> V.value
                 val fallback :
                   string -> V.state -> V.value list -> V.value list
                 val setfallback : V.state -> string -> V.value -> V.value
                 val apply :
                   V.value -> V.state -> V.value list -> V.value list
                 val register_globals :
                   (string * V.value) list -> V.state -> unit
                 val register_module :
                   string -> (string * V.value) list -> V.state -> unit
               end) ->
          sig val init : C.V.state -> unit end
    end