String (stanc.Core.String)

include module type of struct include Base.String end

type t = string

val globalize : t -> t

val t_sexp_grammar : t Sexplib0.Sexp_grammar.t

val sub : (t, t) Base__.Blit.sub

val unsafe_sub : t -> pos:int -> len:int -> t

val subo : (t, t) Base__.Blit.subo

type elt = char

val of_list : elt list -> t

val of_array : elt array -> t

val append : t -> t -> t

val map : t -> f:(elt -> elt) -> t

val filter : t -> f:(elt -> bool) -> t

val filter_map : t -> f:(elt -> elt option) -> t

val partition_tf : t -> f:(elt -> bool) -> t * t

val partition_map : t -> f:(elt -> (elt, elt) Base__.Either0.t) -> t * t

val is_empty : t -> bool

val iter : t -> f:(elt -> unit) -> unit

val fold : t -> init:'acc -> f:('acc -> elt -> 'acc) -> 'acc

val fold_result : 
  t ->
  init:'acc ->
  f:('acc -> elt -> ('acc, 'e) Base__.Result.t) ->
  ('acc, 'e) Base__.Result.t

val fold_until : 
  t ->
  init:'acc ->
  f:('acc -> elt -> ('acc, 'final) Base__Container_intf.Continue_or_stop.t) ->
  finish:('acc -> '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__Container_intf.Summable 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

val foldi : (t, elt, 'a) Base__Indexed_container_intf.foldi

val iteri : (t, elt) Base__Indexed_container_intf.iteri

val existsi : t -> f:(int -> elt -> bool) -> bool

val for_alli : t -> f:(int -> elt -> bool) -> bool

val counti : t -> f:(int -> elt -> bool) -> int

val findi : t -> f:(int -> elt -> bool) -> (int * elt) option

val find_mapi : t -> f:(int -> elt -> 'a option) -> 'a option

val init : int -> f:(int -> elt) -> t

val mapi : t -> f:(int -> elt -> elt) -> t

val filteri : t -> f:(int -> elt -> bool) -> t

val filter_mapi : t -> f:(int -> elt -> elt option) -> t

val hash_fold_t : t Base__Ppx_hash_lib.hash_fold

val t_of_sexp : Sexplib0__.Sexp.t -> t

val sexp_of_t : t -> Sexplib0__.Sexp.t

val of_string : string -> t

val to_string : t -> string

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 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

type comparator_witness = Base__String.comparator_witness

val comparator : (t, comparator_witness) Base__Comparator.comparator

val pp : Base__.Formatter.t -> t -> unit

val hashable : t Base__.Hashable.t

val compare__local : t Base__Ppx_compare_lib.compare__local

val invariant : t Base__Invariant_intf.inv

val max_length : int

val mem : t -> char -> bool

val length : t -> int

val get : t -> int -> char

val unsafe_get : string -> int -> char

val make : int -> char -> t

val (^) : t -> t -> t

val concat : ?sep:??? -> t list -> t

val escaped : t -> t

val contains : ?pos:??? -> ?len:??? -> t -> char -> bool

val uppercase : t -> t

val lowercase : t -> t

val capitalize : t -> t

val uncapitalize : t -> t

module Caseless : sig ... end

val index : t -> char -> int option

val index_exn : t -> char -> int

val index_from : t -> int -> char -> int option

val index_from_exn : t -> int -> char -> int

val rindex : t -> char -> int option

val rindex_exn : t -> char -> int

val rindex_from : t -> int -> char -> int option

val rindex_from_exn : t -> int -> char -> int

val to_sequence : t -> char Base__.Sequence.t

val of_sequence : char Base__.Sequence.t -> t

module Search_pattern : sig ... end

val substr_index : ?pos:??? -> t -> pattern:t -> int option

val substr_index_exn : ?pos:??? -> t -> pattern:t -> int

val substr_index_all : t -> may_overlap:bool -> pattern:t -> int list

val substr_replace_first : ?pos:??? -> 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:??? -> t -> f:(int -> char -> bool) -> int option

val rfindi : ?pos:??? -> t -> f:(int -> char -> bool) -> int option

val lstrip : ?drop:??? -> t -> t

val rstrip : ?drop:??? -> t -> t

val strip : ?drop:??? -> t -> t

val concat_map : ?sep:??? -> t -> f:(char -> t) -> t

val concat_mapi : ?sep:??? -> t -> f:(int -> char -> t) -> t

val tr : target:char -> replacement:char -> t -> t

val tr_multi : target:t -> replacement:t -> (t -> t) Base__.Staged.t

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 chop_suffix_if_exists : t -> suffix:t -> t

val chop_prefix_if_exists : t -> prefix:t -> t

val suffix : t -> int -> t

val prefix : t -> int -> t

val drop_suffix : t -> int -> t

val drop_prefix : t -> int -> t

val common_suffix : t list -> t

val common_prefix : t list -> t

val common_suffix_length : t list -> int

val common_prefix_length : t list -> int

val common_suffix2 : t -> t -> t

val common_prefix2 : t -> t -> t

val common_suffix2_length : t -> t -> int

val common_prefix2_length : t -> t -> int

val concat_array : ?sep:??? -> t array -> t

val concat_lines : ?crlf:??? -> string list -> string

val hash : t -> int

val equal : t -> t -> bool

val equal__local : t -> t -> bool

val of_char : char -> t

val of_char_list : char list -> t

val pad_left : ?char:??? -> string -> len:int -> string

val pad_right : ?char:??? -> string -> len:int -> string

val edit_distance : string -> string -> int

module Escaping : sig ... end

module Utf8 : sig ... end

module Utf16le : sig ... end

module Utf16be : sig ... end

module Utf32le : sig ... end

module Utf32be : sig ... end

module type Utf = sig ... end

module type Utf_as_string = sig ... end

module Table : sig ... end

module Hash_set : sig ... end

module Set : sig ... end

module Map : sig ... end