sig
  module DFA :
    sig
      module S :
        sig
          type t = char
          type 'a 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
  exception Error of string
  type t
  val expr_parse : (char, Cf_regex.DFA.x) Cf_parser.t
  val expr_of_seq : char Cf_seq.t -> Cf_regex.DFA.x
  val expr_of_string : string -> Cf_regex.DFA.x
  val quote : (char, char) Cf_flow.t
  val unquote : (char, char) Cf_flow.t
  val of_expression : Cf_regex.DFA.x -> Cf_regex.t
  val of_seq : char Cf_seq.t -> Cf_regex.t
  val of_string : string -> Cf_regex.t
  val test : Cf_regex.t -> string -> bool
  val search : Cf_regex.t -> char Cf_seq.t -> int * int
  val separate : Cf_regex.t -> char Cf_seq.t -> char Cf_seq.t Cf_seq.t
  val split : Cf_regex.t -> string -> string list
  val parse : Cf_regex.t -> (char, string) Cf_parser.t
  val parsex :
    Cf_regex.t -> ('a #Cf_parser.cursor, char, string) Cf_parser.X.t
end