`include InferStdlib.IStd.String`
`type t``= string```
`val typerep_of_t : t Typerep_lib.Std.Typerep.t`
`val typename_of_t : t Typerep_lib.Std.Typename.t`
`module Caseless = Core_kernel__String.Caseless`
`val blit : (t, bytes) Base__.Blit.blit`

- Deprecated [since 2017-10] Use [Bytes.blit] instead

`val blito : (t, bytes) Base__.Blit.blito`

- Deprecated [since 2017-10] Use [Bytes.blito] instead

`val unsafe_blit : (t, bytes) Base__.Blit.blit`

- Deprecated [since 2017-10] Use [Bytes.unsafe_blit] instead

`val sub : (t, t) Base__.Blit.sub`
`val subo : (t, t) Base__.Blit.subo`
`type elt``= char```
`val mem : t ‑> elt ‑> bool`
`val iter : t ‑> f:(elt ‑> unit) ‑> unit`
`val fold : t ‑> init:'accum ‑> f:('accum ‑> elt ‑> 'accum) ‑> 'accum`
`val fold_result : t ‑> init:'accum ‑> f:('accum ‑> elt ‑> ('accum, 'e) Base__.Result.t) ‑> ('accum, 'e) Base__.Result.t`
`val fold_until : t ‑> init:'accum ‑> f:('accum ‑> elt ‑> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ‑> finish:('accum ‑> 'final) ‑> 'final`
`val exists : t ‑> f:(elt ‑> bool) ‑> bool`
`val for_all : t ‑> f:(elt ‑> bool) ‑> bool`
`val count : t ‑> f:(elt ‑> bool) ‑> int`
`val sum : (module Base__.Commutative_group.S with type t = 'sum) ‑> t ‑> f:(elt ‑> 'sum) ‑> 'sum`
`val find : t ‑> f:(elt ‑> bool) ‑> elt option`
`val find_map : t ‑> f:(elt ‑> 'a option) ‑> 'a option`
`val to_list : t ‑> elt list`
`val to_array : t ‑> elt array`
`val min_elt : t ‑> compare:(elt ‑> elt ‑> int) ‑> elt option`
`val max_elt : t ‑> compare:(elt ‑> elt ‑> int) ‑> elt option`
`type comparator_witness``= Base__String.comparator_witness```
`val max_length : int`
`external length : t ‑> int = "%string_length"`
`external get : t ‑> int ‑> char = "%string_safe_get"`
`external unsafe_get : string ‑> int ‑> char = "%string_unsafe_get"`
`val create : int ‑> bytes`

- Deprecated [since 2017-10] Use [Bytes.create] instead

`val make : int ‑> char ‑> t`
`val copy : t ‑> t`
`val init : int ‑> f:(int ‑> char) ‑> t`
`val fill : bytes ‑> pos:int ‑> len:int ‑> char ‑> unit`

- Deprecated [since 2017-10] Use [Bytes.fill] instead

`val (^) : t ‑> t ‑> t`
`val concat : ?⁠sep:t ‑> t list ‑> t`
`val escaped : t ‑> t`
`val contains : ?⁠pos:int ‑> ?⁠len:int ‑> t ‑> char ‑> bool`
`val uppercase : t ‑> t`
`val lowercase : t ‑> t`
`val capitalize : t ‑> t`
`val uncapitalize : t ‑> t`
`val index : t ‑> char ‑> int option`
`val index_exn : t ‑> char ‑> int`
`val rindex : t ‑> char ‑> int option`
`val rindex_exn : t ‑> char ‑> int`
`val index_from : t ‑> int ‑> char ‑> int option`
`val index_from_exn : t ‑> int ‑> char ‑> int`
`val rindex_from : t ‑> int ‑> char ‑> int option`
`val rindex_from_exn : t ‑> int ‑> char ‑> int`
`module Search_pattern = Core_kernel__String.Search_pattern`
`val substr_index : ?⁠pos:int ‑> t ‑> pattern:t ‑> int option`
`val substr_index_exn : ?⁠pos:int ‑> t ‑> pattern:t ‑> int`
`val substr_index_all : t ‑> may_overlap:bool ‑> pattern:t ‑> int list`
`val substr_replace_first : ?⁠pos:int ‑> t ‑> pattern:t ‑> with_:t ‑> t`
`val substr_replace_all : t ‑> pattern:t ‑> with_:t ‑> t`
`val is_substring : t ‑> substring:t ‑> bool`
`val is_substring_at : t ‑> pos:int ‑> substring:t ‑> bool`
`val to_list_rev : t ‑> char list`
`val rev : t ‑> t`
`val is_suffix : t ‑> suffix:t ‑> bool`
`val is_prefix : t ‑> prefix:t ‑> bool`
`val lsplit2_exn : t ‑> on:char ‑> t * t`
`val rsplit2_exn : t ‑> on:char ‑> t * t`
`val lsplit2 : t ‑> on:char ‑> (t * t) option`
`val rsplit2 : t ‑> on:char ‑> (t * t) option`
`val split : t ‑> on:char ‑> t list`
`val split_on_chars : t ‑> on:char list ‑> t list`
`val split_lines : t ‑> t list`
`val lfindi : ?⁠pos:int ‑> t ‑> f:(int ‑> char ‑> bool) ‑> int option`
`val rfindi : ?⁠pos:int ‑> t ‑> f:(int ‑> char ‑> bool) ‑> int option`
`val lstrip : ?⁠drop:(char ‑> bool) ‑> t ‑> t`
`val rstrip : ?⁠drop:(char ‑> bool) ‑> t ‑> t`
`val strip : ?⁠drop:(char ‑> bool) ‑> t ‑> t`
`val map : t ‑> f:(char ‑> char) ‑> t`
`val mapi : t ‑> f:(int ‑> char ‑> char) ‑> t`
`val foldi : t ‑> init:'a ‑> f:(int ‑> 'a ‑> char ‑> 'a) ‑> 'a`
`val concat_map : ?⁠sep:t ‑> t ‑> f:(char ‑> t) ‑> t`
`val filter : t ‑> f:(char ‑> bool) ‑> t`
`val tr : target:char ‑> replacement:char ‑> t ‑> t`
`val tr_inplace : target:char ‑> replacement:char ‑> bytes ‑> unit`

- Deprecated [since 2017-10] Use [Bytes.tr] instead

`val chop_suffix_exn : t ‑> suffix:t ‑> t`
`val chop_prefix_exn : t ‑> prefix:t ‑> t`
`val chop_suffix : t ‑> suffix:t ‑> t option`
`val chop_prefix : t ‑> prefix:t ‑> t option`
`val suffix : t ‑> int ‑> t`
`val prefix : t ‑> int ‑> t`
`val drop_suffix : t ‑> int ‑> t`
`val drop_prefix : t ‑> int ‑> t`
`val concat_array : ?⁠sep:t ‑> t array ‑> t`
`val is_empty : t ‑> bool`
`val of_char : char ‑> t`
`val of_char_list : char list ‑> t`
`module Escaping = Core_kernel__String.Escaping`
`val set : bytes ‑> int ‑> char ‑> unit`

- Deprecated [since 2017-10] Use [Bytes.set] instead

`val unsafe_set : bytes ‑> int ‑> char ‑> unit`

- Deprecated [since 2017-10] Use [Bytes.unsafe_set] instead

`val slice : t ‑> int ‑> int ‑> t`
`val nget : t ‑> int ‑> char`
`val take_while : t ‑> f:(char ‑> bool) ‑> t`
`val rtake_while : t ‑> f:(char ‑> bool) ‑> t`
`module Hexdump = Core_kernel__String.Hexdump`
`val bin_t : t Bin_prot.Type_class.t`
`val bin_read_t : t Bin_prot.Read.reader`
`val __bin_read_t__ : (Core_kernel__.Import.int ‑> t) Bin_prot.Read.reader`
`val bin_reader_t : t Bin_prot.Type_class.reader`
`val bin_size_t : t Bin_prot.Size.sizer`
`val bin_write_t : t Bin_prot.Write.writer`
`val bin_writer_t : t Bin_prot.Type_class.writer`
`val bin_shape_t : Bin_prot.Shape.t`
`val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> t`
`val sexp_of_t : t ‑> Ppx_sexp_conv_lib.Sexp.t`
`val of_string : string ‑> t`
`val to_string : t ‑> string`
`val pp : Base__.Formatter.t ‑> t ‑> unit`
`val (>=) : t ‑> t ‑> bool`
`val (<=) : t ‑> t ‑> bool`
`val (=) : t ‑> t ‑> bool`
`val (>) : t ‑> t ‑> bool`
`val (<) : t ‑> t ‑> bool`
`val (<>) : t ‑> t ‑> bool`
`val equal : t ‑> t ‑> bool`
`val compare : t ‑> t ‑> int`
`val min : t ‑> t ‑> t`
`val max : t ‑> t ‑> t`
`val ascending : t ‑> t ‑> int`
`val descending : t ‑> t ‑> int`
`val between : t ‑> low:t ‑> high:t ‑> bool`
`val clamp_exn : t ‑> min:t ‑> max:t ‑> t`
`val clamp : t ‑> min:t ‑> max:t ‑> t Base__.Or_error.t`
`val validate_lbound : min:t Base__.Maybe_bound.t ‑> t Base__.Validate.check`
`val validate_ubound : max:t Base__.Maybe_bound.t ‑> t Base__.Validate.check`
`val validate_bound : min:t Base__.Maybe_bound.t ‑> max:t Base__.Maybe_bound.t ‑> t Base__.Validate.check`
`module Replace_polymorphic_compare = Core_kernel__String.Replace_polymorphic_compare`
`val comparator : (t, comparator_witness) Core_kernel__.Comparator.comparator`
`module Map = Core_kernel__String.Map`
`module Set = Core_kernel__String.Set`
`val hash_fold_t : Ppx_hash_lib.Std.Hash.state ‑> t ‑> Ppx_hash_lib.Std.Hash.state`
`val hash : t ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val hashable : t Core_kernel__.Hashtbl.Hashable.t`
`module Table = Core_kernel__String.Table`
`module Hash_set = Core_kernel__String.Hash_set`
`module Hash_queue = Core_kernel__String.Hash_queue`
`val gen : t Core_kernel__.Quickcheck.Generator.t`
`val obs : t Core_kernel__.Quickcheck.Observer.t`
`val shrinker : t Core_kernel__.Quickcheck.Shrinker.t`
`val gen' : char Core_kernel__.Quickcheck.Generator.t ‑> t Core_kernel__.Quickcheck.Generator.t`
`val gen_with_length : int ‑> char Core_kernel__.Quickcheck.Generator.t ‑> t Core_kernel__.Quickcheck.Generator.t`
`module Stable = Core_kernel__String.Stable`
`val pp : Format.formatter ‑> string ‑> unit`
`val make : 'a ‑> 'a`
`val unknown : string`