module Spec :
  sig
    type t = string
    type nt = string
    type prod = unit
    type symbol = Bnf_spec.Spec.symbol = NT of nt | T of t
    val compare_t : t -> t -> int
    val compare_nt : nt -> nt -> int
    val compare_prod : prod -> prod -> int
  end
module Bnf :
  sig
    module Spec :
      sig
        type t = string
        type nt = string
        type prod = unit
        type symbol = Spec.symbol = NT of nt | T of t
        val compare_t : t -> t -> int
        val compare_nt : nt -> nt -> int
        val compare_prod : prod -> prod -> int
      end
    module TSet :
      sig
        type elt = Spec.t
        type t = Bnf_spec.Bnf.TSet.t
        val empty : t
        val is_empty : t -> bool
        val mem : elt -> t -> bool
        val add : elt -> t -> t
        val singleton : elt -> t
        val remove : elt -> t -> t
        val union : t -> t -> t
        val inter : t -> t -> t
        val diff : t -> t -> t
        val compare : t -> t -> int
        val equal : t -> t -> bool
        val subset : t -> t -> bool
        val iter : (elt -> unit) -> t -> unit
        val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
        val for_all : (elt -> bool) -> t -> bool
        val exists : (elt -> bool) -> t -> bool
        val filter : (elt -> bool) -> t -> t
        val partition : (elt -> bool) -> t -> t * t
        val cardinal : t -> int
        val elements : t -> elt list
        val min_elt : t -> elt
        val max_elt : t -> elt
        val choose : t -> elt
        val split : elt -> t -> t * bool * t
      end
    module TMap :
      sig
        type key = Spec.t
        type 'a t = 'a Bnf_spec.Bnf.TMap.t
        val empty : 'a t
        val is_empty : 'a t -> bool
        val add : key -> 'a -> 'a t -> 'a t
        val find : key -> 'a t -> 'a
        val remove : key -> 'a t -> 'a t
        val mem : key -> 'a t -> bool
        val iter : (key -> 'a -> unit) -> 'a t -> unit
        val map : ('a -> 'b) -> 'a t -> 'b t
        val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
        val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
        val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      end
    module NTSet :
      sig
        type elt = Spec.nt
        type t = Bnf_spec.Bnf.NTSet.t
        val empty : t
        val is_empty : t -> bool
        val mem : elt -> t -> bool
        val add : elt -> t -> t
        val singleton : elt -> t
        val remove : elt -> t -> t
        val union : t -> t -> t
        val inter : t -> t -> t
        val diff : t -> t -> t
        val compare : t -> t -> int
        val equal : t -> t -> bool
        val subset : t -> t -> bool
        val iter : (elt -> unit) -> t -> unit
        val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
        val for_all : (elt -> bool) -> t -> bool
        val exists : (elt -> bool) -> t -> bool
        val filter : (elt -> bool) -> t -> t
        val partition : (elt -> bool) -> t -> t * t
        val cardinal : t -> int
        val elements : t -> elt list
        val min_elt : t -> elt
        val max_elt : t -> elt
        val choose : t -> elt
        val split : elt -> t -> t * bool * t
      end
    module NTMap :
      sig
        type key = Spec.nt
        type 'a t = 'a Bnf_spec.Bnf.NTMap.t
        val empty : 'a t
        val is_empty : 'a t -> bool
        val add : key -> 'a -> 'a t -> 'a t
        val find : key -> 'a t -> 'a
        val remove : key -> 'a t -> 'a t
        val mem : key -> 'a t -> bool
        val iter : (key -> 'a -> unit) -> 'a t -> unit
        val map : ('a -> 'b) -> 'a t -> 'b t
        val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
        val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
        val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      end
    module ProdSet :
      sig
        type elt = Spec.prod * Spec.symbol list
        type t = Bnf_spec.Bnf.ProdSet.t
        val empty : t
        val is_empty : t -> bool
        val mem : elt -> t -> bool
        val add : elt -> t -> t
        val singleton : elt -> t
        val remove : elt -> t -> t
        val union : t -> t -> t
        val inter : t -> t -> t
        val diff : t -> t -> t
        val compare : t -> t -> int
        val equal : t -> t -> bool
        val subset : t -> t -> bool
        val iter : (elt -> unit) -> t -> unit
        val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
        val for_all : (elt -> bool) -> t -> bool
        val exists : (elt -> bool) -> t -> bool
        val filter : (elt -> bool) -> t -> t
        val partition : (elt -> bool) -> t -> t * t
        val cardinal : t -> int
        val elements : t -> elt list
        val min_elt : t -> elt
        val max_elt : t -> elt
        val choose : t -> elt
        val split : elt -> t -> t * bool * t
      end
    module ProdMap :
      sig
        type key = Spec.prod * Spec.symbol list
        type 'a t = 'a Bnf_spec.Bnf.ProdMap.t
        val empty : 'a t
        val is_empty : 'a t -> bool
        val add : key -> 'a -> 'a t -> 'a t
        val find : key -> 'a t -> 'a
        val remove : key -> 'a t -> 'a t
        val mem : key -> 'a t -> bool
        val iter : (key -> 'a -> unit) -> 'a t -> unit
        val map : ('a -> 'b) -> 'a t -> 'b t
        val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
        val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
        val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      end
    type grammar = Bnf_spec.Bnf.grammar
    type live_grammar = Bnf_spec.Bnf.live_grammar
    val empty : grammar
    val add_prod :
      grammar -> Spec.nt -> Spec.prod -> Spec.symbol list -> grammar
    val remove_nt : grammar -> Spec.nt -> grammar
    val union : grammar -> grammar -> grammar
    val diff : grammar -> grammar -> grammar
    val inter : grammar -> grammar -> grammar
    val grammar_of_live : live_grammar -> grammar
    val prune_unproductive : grammar -> grammar
    val prune_nonlive : grammar -> live_grammar
    val prune_unreachable : grammar -> Spec.nt -> grammar
    val prune_unreachable_live : live_grammar -> Spec.nt -> live_grammar
    val make_sane : grammar -> Spec.nt -> grammar
    val make_sane_live : grammar -> Spec.nt -> live_grammar
    val grammar_contents : grammar -> ProdSet.t NTMap.t
    val deriv_depth_info : live_grammar -> (int * int ProdMap.t) NTMap.t
    val nts_in_grammar : grammar -> NTSet.t
    val ts_in_grammar : grammar -> TSet.t
    val prods_in_grammar : grammar -> ProdSet.t
    val bounded_grammar :
      grammar -> Spec.nt -> int -> (TSet.t * grammar) list
  end