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