module type USERTYPE =
  sig
    type 'a t
    val tname : string
    val eq : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
    val to_string : ('a -> string) -> 'a t -> string
  end
module type TYPEVIEW =
  sig
    type 'a combined
    type 'a t
    val makemap :
      ('a combined, 'b, 'b) Luavalue.ep ->
      ('b -> string -> 'a t) -> ('a t, 'b, 'b) Luavalue.ep
  end
module type COMBINED_CORE =
  sig
    type 'a also_t
    module type VIEW =
      sig
        type 'a combined = 'a also_t
        type 'a t
        val makemap :
          ('a combined, 'b, 'b) Luavalue.ep ->
          ('b -> string -> 'a t) -> ('a t, 'b, 'b) Luavalue.ep
      end
    module TV1 : VIEW
    module TV2 : VIEW
    module TV3 : VIEW
    module TV4 : VIEW
    module TV5 : VIEW
    module TV6 : VIEW
    module TV7 : VIEW
    module TV8 : VIEW
    module TV9 : VIEW
    module TV10 : VIEW
  end
module type COMBINED_VIEWS =
  sig
    type 'a t
    type 'a also_t = 'a t
    module type VIEW =
      sig
        type 'a combined = 'a also_t
        type 'a t
        val makemap :
          ('a combined, 'b, 'b) Luavalue.ep ->
          ('b -> string -> 'a t) -> ('a t, 'b, 'b) Luavalue.ep
      end
    module TV1 : VIEW
    module TV2 : VIEW
    module TV3 : VIEW
    module TV4 : VIEW
    module TV5 : VIEW
    module TV6 : VIEW
    module TV7 : VIEW
    module TV8 : VIEW
    module TV9 : VIEW
    module TV10 : VIEW
  end
module type COMBINED_TYPE =
  sig
    type 'a t
    val tname : string
    val eq : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
    val to_string : ('a -> string) -> 'a t -> string
    type 'a also_t = 'a t
    module type VIEW =
      sig
        type 'a combined = 'a also_t
        type 'a t
        val makemap :
          ('a combined, 'b, 'b) Luavalue.ep ->
          ('b -> string -> 'a t) -> ('a t, 'b, 'b) Luavalue.ep
      end
    module TV1 : VIEW
    module TV2 : VIEW
    module TV3 : VIEW
    module TV4 : VIEW
    module TV5 : VIEW
    module TV6 : VIEW
    module TV7 : VIEW
    module TV8 : VIEW
    module TV9 : VIEW
    module TV10 : VIEW
  end
module type CORE =
  sig
    module V : Luavalue.S
    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
module type BARECODE =
  functor (C : CORE) -> sig val init : C.V.state -> unit end
module type USERCODE =
  sig
    type 'a userdata'
    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
module WithType :
  functor (T : USERTYPE) ->
    functor (L : BARECODE) ->
      sig
        type 'a userdata' = 'a T.t
        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