functor (Config : ConfigInt.Type->
  sig
    module ISet :
      sig
        type t = (int * int) AvlTree.tree
        type elt = int
        val empty : t
        val is_empty : t -> bool
        val mem : int -> t -> bool
        val add : int -> t -> t
        val add_range : int -> int -> t -> t
        val singleton : int -> t
        val remove : int -> t -> t
        val remove_range : int -> int -> t -> t
        val union : t -> t -> t
        val inter : t -> t -> t
        val diff : t -> t -> t
        val compl : t -> t
        val compare : t -> t -> int
        val equal : t -> t -> bool
        val subset : t -> t -> bool
        val from : int -> t -> t
        val after : int -> t -> t
        val until : int -> t -> t
        val before : int -> t -> t
        val iter : (int -> unit) -> t -> unit
        val iter_range : (int -> int -> unit) -> t -> unit
        val fold : (int -> '-> 'a) -> t -> '-> 'a
        val fold_range : (int -> int -> '-> 'a) -> t -> '-> 'a
        val for_all : (int -> bool) -> t -> bool
        val exists : (int -> bool) -> t -> bool
        val filter : (int -> bool) -> t -> t
        val partition : (int -> bool) -> t -> t * t
        val cardinal : t -> int
        val elements : t -> int list
        val ranges : t -> (int * int) list
        val min_elt : t -> int
        val max_elt : t -> int
        val choose : t -> int
      end
    module IMap :
      sig
        type 'a t = (int * int * 'a) AvlTree.tree
        type key = int
        val empty : 'a t
        val is_empty : 'a t -> bool
        val add : ?eq:('-> '-> bool) -> int -> '-> 'a t -> 'a t
        val add_range :
          ?eq:('-> '-> bool) -> int -> int -> '-> 'a t -> 'a t
        val find : int -> 'a t -> 'a
        val remove : int -> 'a t -> 'a t
        val remove_range : int -> int -> 'a t -> 'a t
        val from : int -> 'a t -> 'a t
        val after : int -> 'a t -> 'a t
        val until : int -> 'a t -> 'a t
        val before : int -> 'a t -> 'a t
        val mem : int -> 'a t -> bool
        val iter : (int -> '-> unit) -> 'a t -> unit
        val iter_range : (int -> int -> '-> unit) -> 'a t -> unit
        val map : ?eq:('-> '-> bool) -> ('-> 'a) -> 'b t -> 'a t
        val mapi :
          ?eq:('-> '-> bool) -> (int -> '-> 'a) -> 'b t -> 'a t
        val fold : (int -> '-> '-> 'b) -> 'a t -> '-> 'b
        val fold_range : (int -> int -> '-> '-> 'b) -> 'a t -> '-> 'b
        val set_to_map : ISet.t -> '-> 'a t
        val domain : 'a t -> ISet.t
        val map_to_set : ('-> bool) -> 'a t -> ISet.t
      end
    module XArray :
      sig
        type 'a xarray = 'XArray.xarray
        type 'a t = 'a xarray
        val init : ?bufsize:int -> int -> '-> (int -> 'a) -> 'a xarray
        val make : ?bufsize:int -> int -> '-> 'a xarray
        val length : 'a xarray -> int
        val get : 'a xarray -> int -> 'a
        val set : 'a xarray -> int -> '-> unit
        type index = XArray.index
        val nth : 'a xarray -> int -> index
        val first : 'a xarray -> index
        val last : 'a xarray -> index
        val look : 'a xarray -> index -> 'a
        val next : 'a t -> index -> index
        val prev : 'a t -> index -> index
        val move : 'a t -> index -> int -> index
        val out_of_range : 'a xarray -> index -> bool
        val compare_index : 'a xarray -> index -> index -> int
        val clear : 'a xarray -> unit
        val reset : 'a xarray -> unit
        val copy : 'a xarray -> 'a xarray
        val sub : 'a xarray -> int -> int -> 'a xarray
        val add_element : 'a xarray -> '-> unit
        val add_array : 'a xarray -> 'a array -> unit
        val add_xarray : 'a xarray -> 'a xarray -> unit
        val append : 'a xarray -> 'a xarray -> 'a xarray
        val iter : ('-> unit) -> 'a xarray -> unit
        val array_of : 'a xarray -> 'a array
        val shrink : 'a xarray -> int -> unit
      end
    module OOChannel :
      sig
        class type ['a] obj_input_channel =
          object method close_in : unit -> unit method get : unit -> 'end
        class type ['a] obj_output_channel =
          object
            method close_out : unit -> unit
            method flush : unit -> unit
            method put : '-> unit
          end
        class ['a] channel_of_stream : 'Stream.t -> ['a] obj_input_channel
        val stream_of_channel : '#obj_input_channel -> 'Stream.t
        class type char_input_channel =
          object
            method close_in : unit -> unit
            method input : string -> int -> int -> int
          end
        class type char_output_channel =
          object
            method close_out : unit -> unit
            method flush : unit -> unit
            method output : string -> int -> int -> int
          end
        class char_input_channel_of :
          char #obj_input_channel -> char_input_channel
        class char_obj_input_channel_of :
          char_input_channel -> [char] obj_input_channel
        class char_output_channel_of :
          char #obj_output_channel -> char_output_channel
        class char_obj_output_channel_of :
          char_output_channel -> [char] obj_output_channel
        class of_in_channel : in_channel -> char_input_channel
        class of_out_channel : out_channel -> char_output_channel
      end
    module UChar :
      sig
        type t = UChar.t
        exception Out_of_range
        val char_of : t -> char
        val of_char : char -> t
        val code : t -> int
        val chr : int -> t
        external uint_code : t -> int = "%identity"
        val chr_of_uint : int -> t
        val eq : t -> t -> bool
        val compare : t -> t -> int
        type uchar = t
        val int_of : uchar -> int
        val of_int : int -> uchar
      end
    module USet :
      sig
        type t = USet.t
        val empty : t
        val is_empty : t -> bool
        val mem : UChar.t -> t -> bool
        val add : UChar.t -> t -> t
        val add_range : UChar.t -> UChar.t -> t -> t
        val singleton : UChar.t -> t
        val remove : UChar.t -> t -> t
        val remove_range : UChar.t -> UChar.t -> t -> t
        val union : t -> t -> t
        val inter : t -> t -> t
        val diff : t -> t -> t
        val compl : t -> t
        val compare : t -> t -> int
        val equal : t -> t -> bool
        val subset : t -> t -> bool
        val from : UChar.t -> t -> t
        val after : UChar.t -> t -> t
        val until : UChar.t -> t -> t
        val before : UChar.t -> t -> t
        val iter : (UChar.t -> unit) -> t -> unit
        val iter_range : (UChar.t -> UChar.t -> unit) -> t -> unit
        val fold : (UChar.t -> '-> 'a) -> t -> '-> 'a
        val fold_range : (UChar.t -> UChar.t -> '-> 'a) -> t -> '-> 'a
        val for_all : (UChar.t -> bool) -> t -> bool
        val exists : (UChar.t -> bool) -> t -> bool
        val filter : (UChar.t -> bool) -> t -> t
        val partition : (UChar.t -> bool) -> t -> t * t
        val cardinal : t -> int
        val elements : t -> UChar.t list
        val ranges : t -> (UChar.t * UChar.t) list
        val min_elt : t -> UChar.t
        val max_elt : t -> UChar.t
        val choose : t -> UChar.t
        val uset_of_iset : ISet.t -> t
        val iset_of_uset : t -> ISet.t
      end
    module UMap :
      sig
        type 'a t = 'UMap.t
        val empty : 'a t
        val is_empty : 'a t -> bool
        val add : ?eq:('-> '-> bool) -> UChar.t -> '-> 'a t -> 'a t
        val add_range :
          ?eq:('-> '-> bool) -> UChar.t -> UChar.t -> '-> 'a t -> 'a t
        val find : UChar.t -> 'a t -> 'a
        val remove : UChar.t -> 'a t -> 'a t
        val remove_range : UChar.t -> UChar.t -> 'a t -> 'a t
        val from : UChar.t -> 'a t -> 'a t
        val after : UChar.t -> 'a t -> 'a t
        val until : UChar.t -> 'a t -> 'a t
        val before : UChar.t -> 'a t -> 'a t
        val mem : UChar.t -> 'a t -> bool
        val iter : (UChar.t -> '-> unit) -> 'a t -> unit
        val iter_range : (UChar.t -> UChar.t -> '-> unit) -> 'a t -> unit
        val map : ?eq:('-> '-> bool) -> ('-> 'a) -> 'b t -> 'a t
        val mapi :
          ?eq:('-> '-> bool) -> (UChar.t -> '-> 'a) -> 'b t -> 'a t
        val fold : (UChar.t -> '-> '-> 'b) -> 'a t -> '-> 'b
        val fold_range :
          (UChar.t -> UChar.t -> '-> '-> 'b) -> 'a t -> '-> 'b
        val set_to_map : USet.t -> '-> 'a t
        val domain : 'a t -> USet.t
        val map_to_set : ('-> bool) -> 'a t -> USet.t
        val umap_of_imap : 'IMap.t -> 'a t
        val imap_of_umap : 'a t -> 'IMap.t
      end
    module UCharTbl :
      sig
        type 'a tbl = 'UCharTbl.tbl
        type 'a t = 'a tbl
        val get : 'a tbl -> UChar.t -> 'a
        module type Type =
          sig
            type elt
            type t = elt tbl
            val get : elt tbl -> UChar.t -> elt
            val of_map : elt -> elt UMap.t -> t
          end
        module Make :
          functor (H : Hashtbl.HashedType->
            sig
              type elt = H.t
              type t = elt tbl
              val get : elt tbl -> UChar.t -> elt
              val of_map : elt -> elt UMap.t -> t
            end
        module Bool :
          sig
            type t = UCharTbl.Bool.t
            val get : t -> UChar.t -> bool
            val of_set : USet.t -> t
          end
        module Bits :
          sig
            type t = UCharTbl.Bits.t
            val of_map : int -> int UMap.t -> t
            val get : t -> UChar.t -> int
          end
        module Bytes :
          sig
            type t = UCharTbl.Bytes.t
            val of_map : int -> int UMap.t -> t
            val get : t -> UChar.t -> int
          end
        module Char :
          sig
            type t = UCharTbl.Char.t
            val of_map : char -> char UMap.t -> t
            val get : t -> UChar.t -> char
          end
      end
    module UnicodeString :
      sig
        module type Type =
          sig
            type t
            val get : t -> int -> UChar.t
            val init : int -> (int -> UChar.t) -> t
            val length : t -> int
            type index
            val look : t -> index -> UChar.t
            val nth : t -> int -> index
            val next : t -> index -> index
            val prev : t -> index -> index
            val out_of_range : t -> index -> bool
            val iter : (UChar.t -> unit) -> t -> unit
            val compare : t -> t -> int
            val first : t -> index
            val last : t -> index
            val move : t -> index -> int -> index
            val compare_index : t -> index -> index -> int
            module Buf :
              sig
                type buf
                val create : int -> buf
                val contents : buf -> t
                val clear : buf -> unit
                val reset : buf -> unit
                val add_char : buf -> UChar.t -> unit
                val add_string : buf -> t -> unit
                val add_buffer : buf -> buf -> unit
              end
          end
      end
    module UText :
      sig
        type mutability = [ `Immutable | `Mutable ]
        type 'a text = 'UText.text
        type utext = [ `Immutable ] text
        type ustring = [ `Mutable ] text
        type t = utext
        val utext_of_ustring : ustring -> utext
        val ustring_of_utext : utext -> ustring
        val get : 'a text -> int -> UChar.t
        val set : ustring -> int -> UChar.t -> unit
        type index = UText.index
        val look : 'a text -> index -> UChar.t
        val nth : 'a text -> int -> index
        val first : 'a text -> index
        val last : 'a text -> index
        val out_of_range : 'a text -> index -> bool
        val compare_index : 'a text -> index -> index -> int
        val next : 'a text -> index -> index
        val prev : 'a text -> index -> index
        val move : 'a text -> index -> int -> index
        val length : 'a text -> int
        val of_string : string -> utext
        val init : int -> (int -> UChar.t) -> utext
        val init_ustring : int -> (int -> UChar.t) -> ustring
        val make : int -> UChar.t -> ustring
        val copy : ustring -> ustring
        val sub : 'a text -> int -> int -> 'a text
        val fill : ustring -> int -> int -> UChar.t -> unit
        val blit : 'a text -> int -> ustring -> int -> int -> unit
        val append : 'a text -> 'b text -> 'a text
        val iter : (UChar.t -> unit) -> 'a text -> unit
        val compare : 'a text -> 'b text -> int
        module Buf :
          sig
            type buf = UText.Buf.buf
            val create : int -> buf
            val contents : buf -> t
            val contents_string : buf -> ustring
            val length : buf -> int
            val clear : buf -> unit
            val reset : buf -> unit
            val add_char : buf -> UChar.t -> unit
            val add_string : buf -> 'a text -> unit
            val add_buffer : buf -> buf -> unit
          end
      end
    module XString :
      sig
        type xstring = XString.xstring
        type t = xstring
        val get : xstring -> int -> UChar.t
        val set : xstring -> int -> UChar.t -> unit
        val length : xstring -> int
        val init : int -> (int -> UChar.t) -> xstring
        type index = XString.index
        val look : xstring -> index -> UChar.t
        val nth : xstring -> int -> index
        val first : xstring -> index
        val last : xstring -> index
        val out_of_range : xstring -> index -> bool
        val next : xstring -> index -> index
        val prev : xstring -> index -> index
        val move : xstring -> index -> int -> index
        val compare_index : xstring -> index -> index -> int
        val make : ?bufsize:int -> int -> UChar.t -> xstring
        val clear : xstring -> unit
        val reset : xstring -> unit
        val copy : xstring -> xstring
        val sub : xstring -> int -> int -> xstring
        val add_char : xstring -> UChar.t -> unit
        val add_text : xstring -> 'UText.text -> unit
        val add_xstring : xstring -> xstring -> unit
        val shrink : xstring -> int -> unit
        val append : xstring -> xstring -> xstring
        val utext_of : xstring -> UText.t
        val ustring_of : xstring -> UText.ustring
        val iter : (UChar.t -> unit) -> xstring -> unit
        val compare : t -> t -> int
        module Buf :
          sig
            type buf = XString.Buf.buf
            val create : int -> buf
            val contents : buf -> t
            val length : buf -> int
            val clear : buf -> unit
            val reset : buf -> unit
            val add_char : buf -> UChar.t -> unit
            val add_string : buf -> t -> unit
            val add_buffer : buf -> buf -> unit
          end
      end
    module SubText :
      sig
        module type Type =
          sig
            type t
            val get : t -> int -> UChar.t
            val init : int -> (int -> UChar.t) -> t
            val length : t -> int
            type index
            val look : t -> index -> UChar.t
            val nth : t -> int -> index
            val first : t -> index
            val last : t -> index
            val next : t -> index -> index
            val prev : t -> index -> index
            val move : t -> index -> int -> index
            val out_of_range : t -> index -> bool
            val compare_index : t -> index -> index -> int
            val iter : (UChar.t -> unit) -> t -> unit
            val compare : t -> t -> int
            module Buf :
              sig
                type buf
                val create : int -> buf
                val contents : buf -> t
                val clear : buf -> unit
                val reset : buf -> unit
                val add_char : buf -> UChar.t -> unit
                val add_string : buf -> t -> unit
                val add_buffer : buf -> buf -> unit
              end
            type ur_text
            type ur_index
            val refer : ur_text -> ur_index -> ur_index -> t
            val excerpt : t -> ur_text
            val context : t -> ur_text * ur_index * ur_index
            val ur_index_of : t -> index -> ur_index
          end
        module Make :
          functor (Text : UnicodeString.Type->
            sig
              type t = SubText.Make(Text).t
              val get : t -> int -> UChar.t
              val init : int -> (int -> UChar.t) -> t
              val length : t -> int
              type index = SubText.Make(Text).index
              val look : t -> index -> UChar.t
              val nth : t -> int -> index
              val first : t -> index
              val last : t -> index
              val next : t -> index -> index
              val prev : t -> index -> index
              val move : t -> index -> int -> index
              val out_of_range : t -> index -> bool
              val compare_index : t -> index -> index -> int
              val iter : (UChar.t -> unit) -> t -> unit
              val compare : t -> t -> int
              module Buf :
                sig
                  type buf = SubText.Make(Text).Buf.buf
                  val create : int -> buf
                  val contents : buf -> t
                  val clear : buf -> unit
                  val reset : buf -> unit
                  val add_char : buf -> UChar.t -> unit
                  val add_string : buf -> t -> unit
                  val add_buffer : buf -> buf -> unit
                end
              type ur_text = Text.t
              type ur_index = Text.index
              val refer : ur_text -> ur_index -> ur_index -> t
              val excerpt : t -> ur_text
              val context : t -> ur_text * ur_index * ur_index
              val ur_index_of : t -> index -> ur_index
            end
      end
    module ULine :
      sig
        type separator = [ `CR | `CRLF | `LF | `LS | `NEL | `PS ]
        class input :
          separator ->
          UChar.t #OOChannel.obj_input_channel ->
          [UChar.t] OOChannel.obj_input_channel
        class output :
          separator ->
          UChar.t #OOChannel.obj_output_channel ->
          [UChar.t] OOChannel.obj_output_channel
        module type Type =
          sig
            type text
            class input_line :
              UChar.t #OOChannel.obj_input_channel ->
              [text] OOChannel.obj_input_channel
            class output_line :
              ?sp:separator ->
              UChar.t #OOChannel.obj_output_channel ->
              [text] OOChannel.obj_output_channel
          end
        module Make :
          functor (Text : UnicodeString.Type->
            sig
              type text = Text.t
              class input_line :
                UChar.t #OOChannel.obj_input_channel ->
                [text] OOChannel.obj_input_channel
              class output_line :
                ?sp:separator ->
                UChar.t #OOChannel.obj_output_channel ->
                [text] OOChannel.obj_output_channel
            end
      end
    module Locale :
      sig
        type t = string
        val read : string -> string -> (in_channel -> 'a) -> string -> 'a
        val contain : string -> string -> bool
      end
    module CharEncoding : CharEncoding.Interface
    module UTF8 :
      sig
        type t = string
        exception Malformed_code
        val validate : t -> unit
        val get : t -> int -> UChar.t
        val init : int -> (int -> UChar.t) -> t
        val length : t -> int
        type index = int
        val nth : t -> int -> index
        val first : t -> index
        val last : t -> index
        val look : t -> index -> UChar.t
        val out_of_range : t -> index -> bool
        val compare_index : t -> index -> index -> int
        val next : t -> index -> index
        val prev : t -> index -> index
        val move : t -> index -> int -> index
        val iter : (UChar.t -> unit) -> t -> unit
        val compare : t -> t -> int
        module Buf :
          sig
            type buf = Buffer.t
            val create : int -> buf
            val contents : buf -> t
            val clear : buf -> unit
            val reset : buf -> unit
            val add_char : buf -> UChar.t -> unit
            val add_string : buf -> t -> unit
            val add_buffer : buf -> buf -> unit
          end
      end
    module UTF16 :
      sig
        type t =
            (int, Bigarray.int16_unsigned_elt, Bigarray.c_layout)
            Bigarray.Array1.t
        exception Malformed_code
        val validate : t -> unit
        val get : t -> int -> UChar.t
        exception Out_of_range
        val init : int -> (int -> UChar.t) -> t
        val length : t -> int
        type index = int
        val nth : t -> int -> index
        val first : t -> index
        val last : t -> index
        val look : t -> index -> UChar.t
        val out_of_range : t -> index -> bool
        val compare_index : t -> index -> index -> int
        val next : t -> index -> index
        val prev : t -> index -> index
        val move : t -> index -> int -> index
        val iter : (UChar.t -> unit) -> t -> unit
        val compare : t -> t -> int
        module Buf :
          sig
            type buf = UTF16.Buf.buf
            val create : int -> buf
            val contents : buf -> t
            val clear : buf -> unit
            val reset : buf -> unit
            val add_char : buf -> UChar.t -> unit
            val add_string : buf -> t -> unit
            val add_buffer : buf -> buf -> unit
          end
      end
    module UCS4 :
      sig
        type t =
            (int32, Bigarray.int32_elt, Bigarray.c_layout) Bigarray.Array1.t
        exception Malformed_code
        val validate : t -> unit
        val get : t -> int -> UChar.t
        val init : int -> (int -> UChar.t) -> t
        val length : t -> int
        type index = int
        val nth : t -> int -> index
        val first : t -> index
        val last : t -> index
        val look : t -> index -> UChar.t
        val out_of_range : t -> index -> bool
        val compare_index : t -> index -> index -> int
        val next : t -> index -> index
        val prev : t -> index -> index
        val move : t -> index -> int -> index
        val iter : (UChar.t -> unit) -> t -> unit
        val compare : t -> t -> int
        module Buf :
          sig
            type buf = UCS4.Buf.buf
            val create : int -> buf
            val contents : buf -> t
            val clear : buf -> unit
            val reset : buf -> unit
            val add_char : buf -> UChar.t -> unit
            val add_string : buf -> t -> unit
            val add_buffer : buf -> buf -> unit
          end
      end
    module UPervasives :
      sig
        type uchar = UChar.t
        val int_of_uchar : uchar -> int
        val uchar_of_int : int -> uchar
        val escaped_uchar : uchar -> string
        val escaped_utf8 : string -> string
        val printer_utf8 : Format.formatter -> string -> unit
        val printer_uchar : Format.formatter -> uchar -> unit
      end
    module URe :
      sig
        type regexp =
            [ `After of regexp
            | `Alt of regexp * regexp
            | `Before of regexp
            | `BoS
            | `EoS
            | `Epsilon
            | `Group of regexp
            | `OneChar
            | `Rep of regexp
            | `Repn of regexp * int * int option
            | `Seq of regexp * regexp
            | `Set of USet.t
            | `String of UChar.t list ]
        type match_semantics = [ `First | `Longest | `Shortest ]
        val no_group : regexp -> regexp
        module type Type =
          sig
            type text
            type index
            type compiled_regexp
            module SubText :
              sig
                type t
                val get : t -> int -> UChar.t
                val init : int -> (int -> UChar.t) -> t
                val length : t -> int
                type index
                val look : t -> index -> UChar.t
                val nth : t -> int -> index
                val first : t -> index
                val last : t -> index
                val next : t -> index -> index
                val prev : t -> index -> index
                val move : t -> index -> int -> index
                val out_of_range : t -> index -> bool
                val compare_index : t -> index -> index -> int
                val iter : (UChar.t -> unit) -> t -> unit
                val compare : t -> t -> int
                module Buf :
                  sig
                    type buf
                    val create : int -> buf
                    val contents : buf -> t
                    val clear : buf -> unit
                    val reset : buf -> unit
                    val add_char : buf -> UChar.t -> unit
                    val add_string : buf -> t -> unit
                    val add_buffer : buf -> buf -> unit
                  end
                type ur_text = text
                type ur_index = index
                val refer : ur_text -> ur_index -> ur_index -> t
                val excerpt : t -> ur_text
                val context : t -> ur_text * ur_index * ur_index
                val ur_index_of : t -> index -> ur_index
              end
            val compile : regexp -> compiled_regexp
            val regexp_match :
              ?sem:match_semantics ->
              compiled_regexp ->
              text -> index -> SubText.t option array option
            val string_match : compiled_regexp -> text -> index -> bool
            val search_forward :
              ?sem:match_semantics ->
              compiled_regexp ->
              text -> index -> SubText.t option array option
          end
        module Make :
          functor (Text : UnicodeString.Type->
            sig
              type text = Text.t
              type index = Text.index
              type compiled_regexp
              module SubText :
                sig
                  type t
                  val get : t -> int -> UChar.t
                  val init : int -> (int -> UChar.t) -> t
                  val length : t -> int
                  type index
                  val look : t -> index -> UChar.t
                  val nth : t -> int -> index
                  val first : t -> index
                  val last : t -> index
                  val next : t -> index -> index
                  val prev : t -> index -> index
                  val move : t -> index -> int -> index
                  val out_of_range : t -> index -> bool
                  val compare_index : t -> index -> index -> int
                  val iter : (UChar.t -> unit) -> t -> unit
                  val compare : t -> t -> int
                  module Buf :
                    sig
                      type buf
                      val create : int -> buf
                      val contents : buf -> t
                      val clear : buf -> unit
                      val reset : buf -> unit
                      val add_char : buf -> UChar.t -> unit
                      val add_string : buf -> t -> unit
                      val add_buffer : buf -> buf -> unit
                    end
                  type ur_text = text
                  type ur_index = index
                  val refer : ur_text -> ur_index -> ur_index -> t
                  val excerpt : t -> ur_text
                  val context : t -> ur_text * ur_index * ur_index
                  val ur_index_of : t -> index -> ur_index
                end
              val compile : regexp -> compiled_regexp
              val regexp_match :
                ?sem:match_semantics ->
                compiled_regexp ->
                text -> index -> SubText.t option array option
              val string_match : compiled_regexp -> text -> index -> bool
              val search_forward :
                ?sem:match_semantics ->
                compiled_regexp ->
                text -> index -> SubText.t option array option
            end
      end
    module UCharInfo : UCharInfo.Type
    module UNF :
      sig
        module type Type = UNF.Type
        module Make :
          functor (Text : UnicodeString.Type->
            sig
              type text = Text.t
              class nfd :
                UChar.t #OOChannel.obj_output_channel ->
                [UChar.t] OOChannel.obj_output_channel
              class nfc :
                UChar.t #OOChannel.obj_output_channel ->
                [UChar.t] OOChannel.obj_output_channel
              class nfkd :
                UChar.t #OOChannel.obj_output_channel ->
                [UChar.t] OOChannel.obj_output_channel
              class nfkc :
                UChar.t #OOChannel.obj_output_channel ->
                [UChar.t] OOChannel.obj_output_channel
              val nfd : text -> text
              val nfkd : text -> text
              val nfc : text -> text
              val nfkc : text -> text
              module NFCBuf :
                sig
                  type buf
                  val create : int -> buf
                  val contents : buf -> text
                  val clear : buf -> unit
                  val reset : buf -> unit
                  val add_char : buf -> UChar.t -> unit
                  val add_string : buf -> text -> unit
                  val add_buffer : buf -> buf -> unit
                end
              val nfc_append : text -> text -> text
              val put_nfd : XString.t -> text -> unit
              val put_nfkd : XString.t -> text -> unit
              val put_nfc : XString.t -> text -> unit
              val put_nfkc : XString.t -> text -> unit
              type index = Text.index
              val nfd_inc :
                text ->
                index -> ([ `Inc of UChar.t list * index * 'a lazy_t ] as 'a)
              val canon_compare : text -> text -> int
              val nfd_decompose : UChar.t -> UChar.t list
              val nfkd_decompose : UChar.t -> UChar.t list
            end
      end
    module UCol :
      sig
        type variable_option =
            [ `Blanked | `Non_ignorable | `Shift_Trimmed | `Shifted ]
        type precision = [ `Primary | `Quaternary | `Secondary | `Tertiary ]
        module type Type = UCol.Type
        module Make :
          functor (Text : UnicodeString.Type->
            sig
              type text = Text.t
              type index = Text.index
              val compare :
                ?locale:string ->
                ?prec:UCol.precision ->
                ?variable:UCol.variable_option -> text -> text -> int
              val sort_key :
                ?locale:string ->
                ?prec:UCol.precision ->
                ?variable:UCol.variable_option -> text -> string
              val compare_with_key :
                ?locale:string ->
                ?prec:UCol.precision ->
                ?variable:UCol.variable_option -> string -> text -> int
              val search_with_key :
                ?locale:string ->
                ?prec:UCol.precision ->
                ?variable:UCol.variable_option ->
                string -> text -> index -> index * index
              val search :
                ?locale:string ->
                ?prec:UCol.precision ->
                ?variable:UCol.variable_option ->
                text -> text -> index -> index * index
            end
      end
    module CaseMap :
      sig
        module type Type = CaseMap.Type
        module Make :
          functor (Text : UnicodeString.Type->
            sig
              type text = Text.t
              val lowercase : ?locale:string -> text -> text
              val uppercase : ?locale:string -> text -> text
              val titlecase : ?locale:string -> text -> text
              val casefolding : text -> text
              val compare_caseless : text -> text -> int
            end
      end
    module UReStr : UReStr.Interface
  end