sig
  module type Symbol_T =
    sig
      type t
      type 'a map
      val map : (Cf_dfa.Symbol_T.t -> 'a) -> 'a Cf_dfa.Symbol_T.map
      val get : 'a Cf_dfa.Symbol_T.map -> Cf_dfa.Symbol_T.t -> 'a
    end
  module type T =
    sig
      module S : Symbol_T
      type x
      type 'a r
      type 'a t = (S.t, 'a) Cf_parser.t
      val nil : Cf_dfa.T.x
      module type Expr_Op_T =
        sig
          val ( $| ) : Cf_dfa.T.x -> Cf_dfa.T.x -> Cf_dfa.T.x
          val ( $& ) : Cf_dfa.T.x -> Cf_dfa.T.x -> Cf_dfa.T.x
          val ( !* ) : Cf_dfa.T.x -> Cf_dfa.T.x
          val ( !+ ) : Cf_dfa.T.x -> Cf_dfa.T.x
          val ( !? ) : Cf_dfa.T.x -> Cf_dfa.T.x
          val ( !: ) : S.t -> Cf_dfa.T.x
          val ( !^ ) : (S.t -> bool) -> Cf_dfa.T.x
          val ( !~ ) : S.t Cf_seq.t -> Cf_dfa.T.x
        end
      module Expr_Op : Expr_Op_T
      module type Op_T =
        sig
          val ( $| ) : x -> x -> x
          val ( $& ) : x -> x -> x
          val ( !* ) : x -> x
          val ( !+ ) : x -> x
          val ( !? ) : x -> x
          val ( !: ) : S.t -> x
          val ( !^ ) : (S.t -> bool) -> x
          val ( !~ ) : S.t Cf_seq.t -> x
          val ( $= ) : Cf_dfa.T.x -> 'a -> 'a Cf_dfa.T.r
          val ( $> ) : Cf_dfa.T.x -> (S.t Cf_seq.t -> 'a) -> 'a Cf_dfa.T.r
          val ( $@ ) : Cf_dfa.T.x -> (int -> 'a Cf_dfa.T.t) -> 'a Cf_dfa.T.r
          val ( !@ ) : 'a Cf_dfa.T.r list -> 'a Cf_dfa.T.r
        end
      module Op : Op_T
      val create : 'a Cf_dfa.T.r -> 'a Cf_dfa.T.t
      module X :
        sig
          type ('b, 'a) r constraint 'b = S.t #Cf_parser.cursor
          type ('b, 'a) t = ('b, S.t, 'a) Cf_parser.X.t
            constraint 'b = S.t #Cf_parser.cursor
          module type Op_T =
            sig
              val ( $| ) : x -> x -> x
              val ( $& ) : x -> x -> x
              val ( !* ) : x -> x
              val ( !+ ) : x -> x
              val ( !? ) : x -> x
              val ( !: ) : S.t -> x
              val ( !^ ) : (S.t -> bool) -> x
              val ( !~ ) : S.t Cf_seq.t -> x
              val ( $= ) :
                Cf_dfa.T.x -> 'a -> (S.t #Cf_parser.cursor, 'a) Cf_dfa.T.X.r
              val ( $> ) :
                Cf_dfa.T.x ->
                (S.t Cf_seq.t -> 'a) ->
                (S.t #Cf_parser.cursor, 'a) Cf_dfa.T.X.r
              val ( $@ ) :
                Cf_dfa.T.x ->
                (int -> (S.t #Cf_parser.cursor as 'b, 'a) Cf_dfa.T.X.t) ->
                ('b, 'a) Cf_dfa.T.X.r
              val ( !@ ) :
                (S.t #Cf_parser.cursor as 'b, 'a) Cf_dfa.T.X.r list ->
                ('b, 'a) Cf_dfa.T.X.r
            end
          module Op : Op_T
          val create :
            (S.t #Cf_parser.cursor as 'b, 'a) Cf_dfa.T.X.r ->
            ('b, 'a) Cf_dfa.T.X.t
        end
    end
  module Create :
    functor (S : Symbol_T) ->
      sig
        module S :
          sig
            type t = S.t
            type 'a map = 'a S.map
            val map : (t -> 'a) -> 'a map
            val get : 'a map -> t -> 'a
          end
        type x
        type 'a r
        type 'a t = (S.t, 'a) Cf_parser.t
        val nil : x
        module type Expr_Op_T =
          sig
            val ( $| ) : x -> x -> x
            val ( $& ) : x -> x -> x
            val ( !* ) : x -> x
            val ( !+ ) : x -> x
            val ( !? ) : x -> x
            val ( !: ) : S.t -> x
            val ( !^ ) : (S.t -> bool) -> x
            val ( !~ ) : S.t Cf_seq.t -> x
          end
        module Expr_Op : Expr_Op_T
        module type Op_T =
          sig
            val ( $| ) : x -> x -> x
            val ( $& ) : x -> x -> x
            val ( !* ) : x -> x
            val ( !+ ) : x -> x
            val ( !? ) : x -> x
            val ( !: ) : S.t -> x
            val ( !^ ) : (S.t -> bool) -> x
            val ( !~ ) : S.t Cf_seq.t -> x
            val ( $= ) : x -> 'a -> 'a r
            val ( $> ) : x -> (S.t Cf_seq.t -> 'a) -> 'a r
            val ( $@ ) : x -> (int -> 'a t) -> 'a r
            val ( !@ ) : 'a r list -> 'a r
          end
        module Op : Op_T
        val create : 'a r -> 'a t
        module X :
          sig
            type ('b, 'a) r constraint 'b = S.t #Cf_parser.cursor
            type ('b, 'a) t = ('b, S.t, 'a) Cf_parser.X.t
              constraint 'b = S.t #Cf_parser.cursor
            module type Op_T =
              sig
                val ( $| ) : x -> x -> x
                val ( $& ) : x -> x -> x
                val ( !* ) : x -> x
                val ( !+ ) : x -> x
                val ( !? ) : x -> x
                val ( !: ) : S.t -> x
                val ( !^ ) : (S.t -> bool) -> x
                val ( !~ ) : S.t Cf_seq.t -> x
                val ( $= ) : x -> 'a -> (S.t #Cf_parser.cursor, 'a) r
                val ( $> ) :
                  x -> (S.t Cf_seq.t -> 'a) -> (S.t #Cf_parser.cursor, 'a) r
                val ( $@ ) :
                  x ->
                  (int -> (S.t #Cf_parser.cursor as 'b, 'a) t) -> ('b, 'a) r
                val ( !@ ) :
                  (S.t #Cf_parser.cursor as 'b, 'a) r list -> ('b, 'a) r
              end
            module Op : Op_T
            val create : (S.t #Cf_parser.cursor as 'b, 'a) r -> ('b, 'a) t
          end
      end
end