sig
  type x = Cf_regex.DFA.x
  type 'a r = 'a Cf_regex.DFA.r
  type 'a t = (char, 'a) Cf_parser.t
  val nil : Cf_lex.x
  val create : 'a Cf_lex.r -> 'a Cf_lex.t
  module type Expr_Op_T =
    sig
      val ( $| ) : Cf_lex.x -> Cf_lex.x -> Cf_lex.x
      val ( $& ) : Cf_lex.x -> Cf_lex.x -> Cf_lex.x
      val ( !* ) : Cf_lex.x -> Cf_lex.x
      val ( !+ ) : Cf_lex.x -> Cf_lex.x
      val ( !? ) : Cf_lex.x -> Cf_lex.x
      val ( !: ) : char -> Cf_lex.x
      val ( !^ ) : (char -> bool) -> Cf_lex.x
      val ( !~ ) : char Cf_seq.t -> Cf_lex.x
      val ( !$ ) : string -> Cf_lex.x
    end
  module Op :
    sig
      val ( $| ) : x -> x -> x
      val ( $& ) : x -> x -> x
      val ( !* ) : x -> x
      val ( !+ ) : x -> x
      val ( !? ) : x -> x
      val ( !: ) : char -> x
      val ( !^ ) : (char -> bool) -> x
      val ( !~ ) : char Cf_seq.t -> x
      val ( !$ ) : string -> x
      val ( $= ) : Cf_lex.x -> 'a -> 'a Cf_lex.r
      val ( $> ) : Cf_lex.x -> (string -> 'a) -> 'a Cf_lex.r
      val ( $@ ) : Cf_lex.x -> (int -> 'a Cf_lex.t) -> 'a Cf_lex.r
      val ( !@ ) : 'a Cf_lex.r list -> 'a Cf_lex.r
      val ( ?~ ) : Cf_lex.x -> string Cf_lex.t
      val ( ?$ ) : string -> string Cf_lex.t
    end
  module X :
    sig
      type ('b, 'a) r constraint 'b = char #Cf_parser.cursor
      type ('b, 'a) t = ('b, char, 'a) Cf_parser.X.t
        constraint 'b = char #Cf_parser.cursor
      val create :
        (char #Cf_parser.cursor as 'b, 'a) Cf_lex.X.r -> ('b, 'a) Cf_lex.X.t
      module Op :
        sig
          val ( $| ) : x -> x -> x
          val ( $& ) : x -> x -> x
          val ( !* ) : x -> x
          val ( !+ ) : x -> x
          val ( !? ) : x -> x
          val ( !: ) : char -> x
          val ( !^ ) : (char -> bool) -> x
          val ( !~ ) : char Cf_seq.t -> x
          val ( !$ ) : string -> x
          val ( $= ) :
            Cf_lex.x -> 'a -> (char #Cf_parser.cursor, 'a) Cf_lex.X.r
          val ( $> ) :
            Cf_lex.x ->
            (string -> 'a) -> (char #Cf_parser.cursor, 'a) Cf_lex.X.r
          val ( $@ ) :
            Cf_lex.x ->
            (int -> (char #Cf_parser.cursor as 'b, 'a) Cf_lex.X.t) ->
            ('b, 'a) Cf_lex.X.r
          val ( !@ ) :
            (char #Cf_parser.cursor as 'b, 'a) Cf_lex.X.r list ->
            ('b, 'a) Cf_lex.X.r
          val ( ?~ ) :
            Cf_lex.x -> (char #Cf_parser.cursor, string) Cf_lex.X.t
          val ( ?$ ) : string -> (char #Cf_parser.cursor, string) Cf_lex.X.t
        end
    end
  type counter = { c_pos : int; c_row : int; c_col : int; }
  val counter_zero : Cf_lex.counter
  class cursor :
    ?c:Cf_lex.counter ->
    string ->
    object ('a)
      val col_ : int
      val nl0_ : char list
      val nlz_ : char list
      val position_ : int
      val row_ : int
      method advance : char -> 'a
      method col : int
      method counter : Cf_lex.counter
      method private next : char -> int * int * char list
      method position : int
      method row : int
    end
end