functor (X : Alphabet.T) ->
  sig
    type t =
        Letter of X.t
      | Union of Automaton.Regexp.t * Automaton.Regexp.t
      | Empty
      | Concat of Automaton.Regexp.t * Automaton.Regexp.t
      | Singl
      | Star of Automaton.Regexp.t
    val letter : X.t -> Automaton.Regexp.t
    val union :
      Automaton.Regexp.t -> Automaton.Regexp.t -> Automaton.Regexp.t
    val empty : Automaton.Regexp.t
    val concat :
      Automaton.Regexp.t -> Automaton.Regexp.t -> Automaton.Regexp.t
    val star : Automaton.Regexp.t -> Automaton.Regexp.t
    val unions : Automaton.Regexp.t list -> Automaton.Regexp.t
    val to_string : Automaton.Regexp.t -> string
    val simpl : Automaton.Regexp.t -> Automaton.Regexp.t
    module Series :
      sig
        type t = Field.Int.t Weak.t ref * (int -> Field.Int.t)
        val eq : t -> t -> 'a
        val get : t -> int -> Field.Int.t
        val coeff : t -> int -> Field.Int.t
        val to_string : t -> string
        val make : (int -> Field.Int.t) -> t
        val zero : t
        val one : t
        val var : t
        val add : t -> t -> t
        val sub : t -> t -> t
        val mul : t -> t -> t
        val expn : t -> int -> t
        val hadamard : t -> t -> t
        val cmul : Field.Int.t -> t -> t
        val neg : t -> t
        val star : t -> t
        val inv : t -> t
        module Polynomial :
          sig
            type t = Field.Int.t array
            val length : t -> int
            val degree : t -> int
            val eq : t -> t -> bool
            val compact : t -> t
            val coeff : t -> int -> Field.Int.t
            val init : int -> (int -> Field.Int.t) -> t
            val add : t -> t -> t
            val zero : 'a array
            val cmul : Field.Int.t -> t -> t
            val neg : t -> t
            val sub : t -> t -> t
            val mul : t -> t -> t
            val one : Field.Int.t array
            val to_string : t -> string
            val monomial : Field.Int.t -> int -> Field.Int.t array
          end
        val polynomial : Polynomial.t -> t
        module RationalFractions :
          sig
            module Polynomial :
              functor (F : Field.T) ->
                sig
                  type t = Ring.Polynomial(F).t
                  val eq : t -> t -> bool
                  val add : t -> t -> t
                  val zero : t
                  val neg : t -> t
                  val mul : t -> t -> t
                  val one : t
                  val to_string : t -> string
                  val div : t -> t -> t * t
                end
            type t = Polynomial(Field.Int).t * Polynomial(Field.Int).t
            val gcd :
              Polynomial(Field.Int).t ->
              Polynomial(Field.Int).t -> Polynomial(Field.Int).t
            val canonize : t -> t
            val eq : t -> t -> bool
            val add : t -> t -> t
            val zero : t
            val neg : t -> t
            val mul : t -> t -> t
            val one : t
            val inv : t -> t
            val to_string : t -> string
          end
        val rational : RationalFractions.t -> t
      end
    val series : Automaton.Regexp.t -> Automaton.Regexp.Series.t
  end