module type S =
  sig
    module Value : Luavalue.S
    type value = Value.value
    type name = string
    type location = int
    type stmt =
        Stmt' of location * stmt
      | Assign of lval list * exp list
      | WhileDo of exp * block
      | RepeatUntil of block * exp
      | If of exp * block * (exp * block) list * block option
      | Return of exp list
      | Callstmt of call
      | Local of name list * exp list
    and block = stmt list
    and lval = Lvar of name | Lindex of exp * exp
    and exp =
        Var of name
      | Lit of value
      | Binop of exp * op * exp
      | Unop of op * exp
      | Index of exp * exp
      | Table of exp list * (name * exp) list
      | Call of call
    and call = Funcall of exp * exp list | Methcall of exp * name * exp list
    and op =
        And
      | Or
      | Lt
      | Le
      | Gt
      | Ge
      | Eq
      | Ne
      | Concat
      | Plus
      | Minus
      | Times
      | Div
      | Not
      | Pow
    type chunk =
        Debug of bool
      | Statement of stmt
      | Fundef of location * lval * name list * varargs * block
      | Methdef of location * exp * name * name list * varargs * block
    and varargs = bool
  end
module Make :
  functor (V : Luavalue.S) ->
    sig
      module Value :
        sig
          type 'a userdata' = 'a V.userdata'
          type srcloc = V.srcloc
          type initstate = V.initstate
          type value =
            V.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 =
            V.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 =
            V.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 = 'a V.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 = V.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
      type value = Value.value
      type name = string
      type location = int
      type stmt =
        Luaast.Make(V).stmt =
          Stmt' of location * stmt
        | Assign of lval list * exp list
        | WhileDo of exp * block
        | RepeatUntil of block * exp
        | If of exp * block * (exp * block) list * block option
        | Return of exp list
        | Callstmt of call
        | Local of name list * exp list
      and block = stmt list
      and lval = Luaast.Make(V).lval = Lvar of name | Lindex of exp * exp
      and exp =
        Luaast.Make(V).exp =
          Var of name
        | Lit of value
        | Binop of exp * op * exp
        | Unop of op * exp
        | Index of exp * exp
        | Table of exp list * (name * exp) list
        | Call of call
      and call =
        Luaast.Make(V).call =
          Funcall of exp * exp list
        | Methcall of exp * name * exp list
      and op =
        Luaast.Make(V).op =
          And
        | Or
        | Lt
        | Le
        | Gt
        | Ge
        | Eq
        | Ne
        | Concat
        | Plus
        | Minus
        | Times
        | Div
        | Not
        | Pow
      type chunk =
        Luaast.Make(V).chunk =
          Debug of bool
        | Statement of stmt
        | Fundef of location * lval * name list * varargs * block
        | Methdef of location * exp * name * name list * varargs * block
      and varargs = bool
    end