Functor CamlinternalMenhirLib.InspectionTableInterpreter.Make

module Make: functor (TT : CamlinternalMenhirLib.TableFormat.TABLES) -> functor (IT : CamlinternalMenhirLib.InspectionTableFormat.TABLES 
        with type 'a lr1state = int) -> functor (ET : CamlinternalMenhirLib.EngineTypes.TABLE 
        with type terminal = int
         and type nonterminal = int
         and type semantic_value = Obj.t) -> functor (E : sig

type env('a) =
  CamlinternalMenhirLib.EngineTypes.env(
    ET.state,
    ET.semantic_value,
    ET.token,
  );

end) -> CamlinternalMenhirLib.IncrementalEngine.INSPECTION 
  with type 'a terminal := 'a IT.terminal
   and type 'a nonterminal := 'a IT.nonterminal
   and type 'a lr1state := 'a IT.lr1state
   and type production := int
   and type 'a env := 'a E.env

include CamlinternalMenhirLib.IncrementalEngine.SYMBOLS;

type lr1state('a);

type production;

type item = (production, int);

let compare_terminals: (terminal('a), terminal('b)) => int;

let compare_nonterminals: (nonterminal('a), nonterminal('b)) => int;

let compare_symbols: (xsymbol, xsymbol) => int;

let compare_productions: (production, production) => int;

let compare_items: (item, item) => int;

let incoming_symbol: lr1state('a) => symbol('a);

let items: lr1state('a) => list(item);

let lhs: production => xsymbol;

let rhs: production => list(xsymbol);

let nullable: nonterminal('a) => bool;

let first: (nonterminal('a), terminal('b)) => bool;

let xfirst: (xsymbol, terminal('a)) => bool;

let foreach_terminal: ((xsymbol, 'a) => 'a, 'a) => 'a;

let foreach_terminal_but_error: ((xsymbol, 'a) => 'a, 'a) => 'a;

type env('a);

let feed:
  (
    symbol('a),
    CamlinternalMenhirLib.IncrementalEngine.position,
    'a,
    CamlinternalMenhirLib.IncrementalEngine.position,
    env('b)
  ) =>
  env('b);