Module Core_extended.Std.String

include Core.String

This module extends Base.String.

type t = string
include sig ... end
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (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 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
include module type of sig ... end with type t := t with module Caseless := Base.String.Caseless
type t = string
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
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.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 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 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
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
external hash : t ‑> int = "Base_hash_string"
val equal : t ‑> t ‑> bool
val is_empty : t ‑> bool
val of_char : char ‑> t
val of_char_list : char list ‑> t
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

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 Core_kernel.Hexdump.S with type t := t
type t
module Hexdump : sig ... end
include Core_kernel.Identifiable.S with type t := t and type comparator_witness := comparator_witness
type t
include sig ... end
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 hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t
include Core_kernel.Identifiable.S_common with type t := t
type t
include sig ... end
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 ‑> Base.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 Core_kernel.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
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 Core_kernel.Comparator.S with type t := t
type t
type comparator_witness
include Core_kernel.Hashable.S_binable with type t := t
type t
include sig ... end
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
include Core_kernel.Quickcheckable.S with type t := t
type 'a gen
type 'a obs
type 'a shr
type t
val gen : t gen
val obs : t obs
val shrinker : t shr
val gen' : char Core_kernel.Quickcheck.Generator.t ‑> t Core_kernel.Quickcheck.Generator.t

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

val gen_with_length : int ‑> char Core_kernel.Quickcheck.Generator.t ‑> t Core_kernel.Quickcheck.Generator.t

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

module Stable = Core_kernel.String.Stable

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 and String.Stable.Map, and provide interface uniformity with other stable types.

include Extended_string

Extensions to Core.Core_String.

val collate : string ‑> string ‑> int

collate s1 s2 sorts string in an order that's usaully more suited for human consumption by treating ints specially, e.g. it will output: ["rfc1.txt";"rfc822.txt";"rfc2086.txt"].

It works by splitting the strings in numerical and non-numerical chunks and comparing chunks two by two from left to right (and starting on a non numerical chunk):

  • Non_numerical chunks are compared using lexicographical ordering.
  • Numerical chunks are compared based on the values of the represented ints and the number of trailing zeros.

It is a total order.

val unescaped : ?⁠strict:bool ‑> string ‑> string

unescaped s is the inverse operation of escaped: it takes a string where all the special characters are escaped following the lexical convention of OCaml and returns an unescaped copy. The strict switch is on by default and makes the function treat illegal backslashes as errors. When strict is false every illegal backslash except escaped numeral greater than 255 is copied literally. The aforementioned numerals still raise errors. This mimics the behaviour of the ocaml lexer.

val unescaped_res : ?⁠strict:bool ‑> string ‑> (string, int * string) Core.Result.t

Same as unescaped but instead of raising Failure _ returns an error message with the position in the string in case of failure.

val squeeze : string ‑> string

squeeze str reduces all sequences of spaces, newlines, tables, and * carriage returns to single spaces.

val is_substring_deprecated : substring:string ‑> string ‑> bool

Use Core.String.is_substring instead of this function. This wrapper is here (for now) to maintain bug compatibility.

val pad_left : ?⁠char:char ‑> string ‑> int ‑> string

pad_left ~char s len Returns s padded to the length len by adding characters char to the left of the string. If s is already longer than len it is returned unchanged.

val pad_right : ?⁠char:char ‑> string ‑> int ‑> string
val line_break : len:int ‑> string ‑> string list

deprecated in favour of word_wrap

val word_wrap : ?⁠trailing_nl:bool ‑> ?⁠soft_limit:int ‑> ?⁠hard_limit:int ‑> ?⁠nl:string ‑> string ‑> string

word_wrap ~soft_limit s

Wraps the string so that it fits the length soft_limit. It doesn't break words unless we go over hard_limit.

if nl is passed it is inserted instead of the normal newline character.

val edit_distance : ?⁠transpose:unit ‑> string ‑> string ‑> int

Gives the Levenshtein distance between 2 strings, which is the number of insertions, deletions, and substitutions necessary to turn either string into the other. With the transpose argument, it alsos considers transpositions (Damerau-Levenshtein distance).