File "miniMLparser.mly", line 55, characters 7-13:
Warning: the token LIDENT is unused.
%{

open Modules
open MiniML
open MLTyping

let variables = ref ([] : (string * ML.type_variable) list)

let reset_type_variables () =
  variables := []

let find_type_variable name =
  try
    List.assoc name !variables
  with Not_found ->
    let v = newvar() in
    variables := (name, v) :: !variables;
    v

let binop op arg1 arg2 =
  ML.Apply(ML.Apply(ML.Longident(Pident(Ident.create op)), arg1), arg2)
let ternop op arg1 arg2 arg3 =
  ML.Apply(ML.Apply(ML.Apply(ML.Longident(Pident(Ident.create op)), arg1), arg2), arg3)

%}
%start implementation
%start phrase
%token ARROW
%token COLON
%token COMMA
%token DOT
%token ELSE
%token END
%token EOF
%token EQUAL
%token EQUALEQUAL
%token FUNCTION
%token FUNCTOR
%token GREATER
%token GREATEREQUAL
%token <string> IDENT
%token IF
%token IN
%token <int> INT
%token LESS
%token LESSEQUAL
%token LESSGREATER
%token LET
%token LIDENT
%token LPAREN
%token MINUS
%token MODULE
%token PLUS
%token QUOTE
%token RPAREN
%token SEMICOLON
%token SEMISEMI
%token SIG
%token SLASH
%token STAR
%token STRUCT
%token THEN
%token TYPE
%token VALUE
%right ARROW
%right COMMA
%right GREATER GREATEREQUAL LESS LESSEQUAL LESSGREATER
%right MINUS PLUS
%right SLASH STAR
%type <MiniML.MLMod.mod_term> implementation
%type <MiniML.MLMod.definition> phrase
%%

path:
  _1 = IDENT
    {                    ( Pident(Ident.create _1) )}
| _1 = path _2 = DOT _3 = IDENT
    {                    ( Pdot(_1, _3) )}

valexpr:
  _1 = valexpr1
    {                                      ( _1 )}
| _1 = valexpr _2 = COMMA _3 = valexpr
    {                                      ( binop "," _1 _3 )}
| _1 = valexpr _2 = PLUS _3 = valexpr
    {                                      ( binop "+" _1 _3 )}
| _1 = valexpr _2 = MINUS _3 = valexpr
    {                                      ( binop "-" _1 _3 )}
| _1 = valexpr _2 = STAR _3 = valexpr
    {                                      ( binop "*" _1 _3 )}
| _1 = valexpr _2 = SLASH _3 = valexpr
    {                                      ( binop "/" _1 _3 )}
| _1 = valexpr _2 = EQUALEQUAL _3 = valexpr
    {                                      ( binop "==" _1 _3 )}
| _1 = valexpr _2 = LESSGREATER _3 = valexpr
    {                                      ( binop "<>" _1 _3 )}
| _1 = valexpr _2 = LESS _3 = valexpr
    {                                      ( binop "<" _1 _3 )}
| _1 = valexpr _2 = LESSEQUAL _3 = valexpr
    {                                      ( binop "<=" _1 _3 )}
| _1 = valexpr _2 = GREATER _3 = valexpr
    {                                      ( binop ">" _1 _3 )}
| _1 = valexpr _2 = GREATEREQUAL _3 = valexpr
    {                                      ( binop ">=" _1 _3 )}
| _1 = FUNCTION _2 = IDENT _3 = ARROW _4 = valexpr
    {                                      ( ML.Function(Ident.create _2, _4) )}
| _1 = LET _2 = IDENT _3 = valbind _4 = IN _5 = valexpr
    {                                      ( ML.Let(Ident.create _2, _3, _5) )}
| _1 = IF _2 = valexpr _3 = THEN _4 = valexpr _5 = ELSE _6 = valexpr
    {                                         ( ternop "conditional" _2 _4 _6 )}

valexpr1:
  _1 = valexpr0
    {             ( _1 )}
| _1 = valexpr1 _2 = valexpr0
    {                      ( ML.Apply(_1, _2) )}

valexpr0:
  _1 = path
    {         ( ML.Longident(_1) )}
| _1 = INT
    {         ( ML.Constant _1 )}
| _1 = LPAREN _2 = valexpr _3 = RPAREN
    {                          ( _2 )}

valbind:
  _1 = EQUAL _2 = valexpr
    {                      ( _2 )}
| _1 = IDENT _2 = valbind
    {                      ( ML.Function(Ident.create _1, _2) )}

simpletype:
  _1 = QUOTE _2 = IDENT
    {                            ( ML.Var(find_type_variable _2) )}
| _1 = simpletype _2 = ARROW _3 = simpletype
    {                                ( ML.Typeconstr(path_arrow, [_1; _3]) )}
| _1 = simpletype _2 = STAR _3 = simpletype
    {                                ( ML.Typeconstr(path_star, [_1; _3]) )}
| _1 = path
    {                            ( ML.Typeconstr(_1, []) )}
| _1 = simpletype _2 = path
    {                            ( ML.Typeconstr(_2, [_1]) )}
| _1 = LPAREN _2 = simpletypelist _3 = RPAREN _4 = path
    {                                      ( ML.Typeconstr(_4, List.rev _2) )}

simpletypelist:
  _1 = simpletype
    {               ( [_1] )}
| _1 = simpletypelist _2 = COMMA _3 = simpletype
    {                                    ( _3::_1 )}

valuedecl:
  _1 = colon_begin_scheme _2 = simpletype
    {            ( reset_type_variables(); end_def(); generalize _2 )}

colon_begin_scheme:
  _1 = COLON
    {            ( begin_def(); reset_type_variables() )}

typedecl:
  _1 = typeparams _2 = IDENT
    {                            ( (_2, {ML.arity = List.length _1}) )}

typedef:
  _1 = typeparams _2 = IDENT _3 = EQUAL _4 = simpletype
    {      ( reset_type_variables();
        (_2, {ML.arity = List.length _1}, {ML.params = _1; ML.defbody = _4}) )}

typeparams:
  
    {                                ( [] )}
| _1 = typeparam
    {                                ( [_1] )}
| _1 = LPAREN _2 = typeparamlist _3 = RPAREN
    {                                ( List.rev _2 )}

typeparamlist:
  _1 = typeparam
    {                                    ( [_1] )}
| _1 = typeparamlist _2 = COMMA _3 = typeparam
    {                                    ( _3 :: _1 )}

typeparam:
  _1 = QUOTE _2 = IDENT
    {                ( find_type_variable _2 )}

typeinfo:
  _1 = typedef
    {              ( let (id, kind, def) = _1 in
                (id, {MLMod.kind = kind; MLMod.manifest = Some def}))}
| _1 = typedecl
    {              ( let (id, kind) = _1 in
                (id, {MLMod.kind = kind; MLMod.manifest = None}) )}

modulexpr:
  _1 = path
    {                                      ( MLMod.Longident _1 )}
| _1 = STRUCT _2 = structure _3 = END
    {                                      ( MLMod.Structure(List.rev _2) )}
| _1 = FUNCTOR _2 = LPAREN _3 = IDENT _4 = COLON _5 = moduletype _6 = RPAREN _7 = modulexpr
    {                                      ( MLMod.Functor(Ident.create _3, _5, _7) )}
| _1 = modulexpr _2 = LPAREN _3 = modulexpr _4 = RPAREN
    {                                      ( MLMod.Apply(_1, _3) )}
| _1 = LPAREN _2 = modulexpr _3 = RPAREN
    {                                      ( _2 )}
| _1 = modulexpr _2 = COLON _3 = moduletype
    {                                      ( MLMod.Constraint(_1, _3) )}

structure:
  
    {                                      ( [] )}
| _1 = structure _2 = structure_item _3 = opt_semi
    {                                      ( _2 :: _1 )}

structure_item:
  _1 = VALUE _2 = IDENT _3 = valbind
    {                                  ( MLMod.Value_str(Ident.create _2, _3) )}
| _1 = TYPE _2 = typedef
    {                                  ( let (id, kind, def) = _2 in
                                    MLMod.Type_str(Ident.create id, kind, def) )}
| _1 = MODULE _2 = IDENT _3 = COLON _4 = moduletype _5 = EQUAL _6 = modulexpr
    {                     ( MLMod.Module_str(Ident.create _2, MLMod.Constraint(_6, _4)) )}
| _1 = MODULE _2 = IDENT _3 = EQUAL _4 = modulexpr
    {                                   ( MLMod.Module_str(Ident.create _2, _4) )}

opt_semi:
  
    {                  ( () )}
| _1 = SEMICOLON
    {              ( () )}

moduletype:
  _1 = SIG _2 = signature _3 = END
    {                                    ( MLMod.Signature(List.rev _2) )}
| _1 = FUNCTOR _2 = LPAREN _3 = IDENT _4 = COLON _5 = moduletype _6 = RPAREN _7 = moduletype
    {                                    ( MLMod.Functor_type(Ident.create _3, _5, _7) )}
| _1 = LPAREN _2 = moduletype _3 = RPAREN
    {                                    ( _2 )}

signature:
  
    {                                      ( [] )}
| _1 = signature _2 = signature_item _3 = opt_semi
    {                                      ( _2 :: _1 )}

signature_item:
  _1 = VALUE _2 = IDENT _3 = valuedecl
    {                                      ( MLMod.Value_sig(Ident.create _2, _3) )}
| _1 = TYPE _2 = typeinfo
    {                     ( let (id, def) = _2 in MLMod.Type_sig(Ident.create id, def) )}
| _1 = MODULE _2 = IDENT _3 = COLON _4 = moduletype
    {                                      ( MLMod.Module_sig(Ident.create _2, _4) )}

phrase:
  _1 = structure_item _2 = SEMISEMI
    {                                      ( _1 )}
| _1 = EOF
    {                                      ( raise End_of_file )}

implementation:
  _1 = modulexpr _2 = EOF
    {                                      ( _1 )}

%%