module type VALUE =
  sig
    type '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.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
module type USERDATA =
  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 AST = Luaast.S
module Parser :
  sig
    type token = Luaparser.token
    module type S =
      sig
        type chunk
        val chunks : (Lexing.lexbuf -> token) -> Lexing.lexbuf -> chunk list
      end
    module type MAKER =
      functor (Ast : AST) ->
        sig
          type chunk = Ast.chunk
          val chunks :
            (Lexing.lexbuf -> token) -> Lexing.lexbuf -> chunk list
        end
    module MakeStandard :
      functor (Ast : AST) ->
        sig
          type chunk = Ast.chunk
          val chunks :
            (Lexing.lexbuf -> token) -> Lexing.lexbuf -> chunk list
        end
  end
module Lib :
  sig
    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