Module Core_kernel.String

This module extends Base.String.

include module type of sig ... end
type t = string
val t_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
val sub : (t, t) Base.Blit.sub
val subo : (t, t) Base.Blit.subo
type elt = char
val mem : t -> elt -> bool
val is_empty : t -> 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__.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 hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
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 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
val pp : Base.Formatter.t -> t -> unit
val invariant : t Base__.Invariant_intf.inv
val max_length : int
val length : t -> int
val get : t -> int -> char
val unsafe_get : string -> int -> char
val make : int -> char -> t
val copy : t -> t
val init : int -> f:(int -> char) -> t
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 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 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_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 concat_array : ?⁠sep:t -> t array -> t
val hash : t -> int
val equal : t -> t -> bool
val of_char : char -> t
val of_char_list : char list -> t
type t = string
include Bin_prot.Binable.S with type t := t
type t
include Bin_prot.Binable.S_only_functions with type t := t
type t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
include Typerep_lib.Typerepable.S with type t := t
type t
val typerep_of_t : t Typerep_lib.Std_internal.Typerep.t
val typename_of_t : t Typerep_lib.Typename.t
module Caseless : sig ... end

Caseless compares and hashes strings ignoring case, so that for example Caseless.equal "OCaml" "ocaml" and Caseless.("apple" < "Banana") are true, and Caseless.Map, Caseless.Table lookup and Caseless.Set membership is case-insensitive.

val slice : t -> int -> int -> t

slice t start stop returns a new string including elements t.(start) through t.(stop-1), normalized Python-style with the exception that stop = 0 is treated as stop = length t.

val nget : t -> int -> char

nget s i gets the char at normalized position i in s.

val take_while : t -> f:(char -> bool) -> t

take_while s ~f returns the longest prefix of s satisfying for_all prefix ~f (See lstrip to drop such a prefix)

val rtake_while : t -> f:(char -> bool) -> t

rtake_while s ~f returns the longest suffix of s satisfying for_all suffix ~f (See rstrip to drop such a suffix)

include Hexdump.S with type t := t
type t
module Hexdump : sig ... end
include Identifiable.S with type t := t and type comparator_witness := comparator_witness
type t
include Bin_prot.Binable.S with type t := t
type t
include Bin_prot.Binable.S_only_functions with type t := t
type t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
include Ppx_sexp_conv_lib.Sexpable.S with type t := t
type t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
include Identifiable.S_common with type t := t
type t
val compare : t -> t -> Core_kernel__.Import.int
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
include Core_kernel__.Import.Stringable.S with type t := t
type t
val of_string : string -> t
val to_string : t -> string
include Core_kernel__.Import.Pretty_printer.S with type t := t
type t
val pp : Base.Formatter.t -> t -> unit
include Comparable.S_binable with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable.S
include Base__.Comparable_intf.Polymorphic_compare
include Base.Comparisons.Infix
type t
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

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool

between t ~low ~high means low <= t <= high

val clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Base.Comparator.S with type t := t
type t
type comparator_witness
val comparator : (t, comparator_witness) Base.Comparator.comparator
include Base__.Comparable_intf.Validate with type t := t
type 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
include Core_kernel__.Comparable_intf.Map_and_set_binable with type t := t with type comparator_witness := comparator_witness
type t
include Comparator.S with type t := t
type t
type comparator_witness
val comparator : (t, comparator_witness) Comparator.comparator
include Hashable.S_binable with type t := t
type t
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
val hashable : t Hashtbl.Hashable.t
module Table : Hashtbl.S_binable with type key = t
module Hash_set : Hash_set.S_binable with type elt = t
module Hash_queue : Hash_queue.S with type key = t
include Quickcheckable.S with type t := t
type t
val quickcheck_generator : t Base_quickcheck.Generator.t
val quickcheck_observer : t Base_quickcheck.Observer.t
val quickcheck_shrinker : t Base_quickcheck.Shrinker.t
val gen_nonempty : t Quickcheck.Generator.t

Like gen, but without empty strings.

val gen' : char Quickcheck.Generator.t -> t Quickcheck.Generator.t

Like gen, but generate strings with the given distribution of characters.

val gen_nonempty' : char Quickcheck.Generator.t -> t Quickcheck.Generator.t

Like gen', but without empty strings.

val gen_with_length : int -> char Quickcheck.Generator.t -> t Quickcheck.Generator.t

Like gen', but generate strings with the given length.

module Stable : sig ... end

Note that string is already stable by itself, since as a primitive type it is an integral part of the sexp / bin_io protocol. String.Stable exists only to introduce String.Stable.Set, String.Stable.Map, String.Stable.Table, and provide interface uniformity with other stable types.