Module Unprime_string.String

include module type of Stdlib.String
val length : string -> int
val get : string -> int -> char
val set : bytes -> int -> char -> unit
val create : int -> bytes
val make : int -> char -> string
val init : int -> (int -> char) -> string
val copy : string -> string
val sub : string -> int -> int -> string
val fill : bytes -> int -> int -> char -> unit
val blit : string -> int -> bytes -> int -> int -> unit
val concat : string -> string list -> string
val iter : (char -> unit) -> string -> unit
val iteri : (int -> char -> unit) -> string -> unit
val map : (char -> char) -> string -> string
val mapi : (int -> char -> char) -> string -> string
val trim : string -> string
val escaped : string -> string
val index : string -> char -> int
val index_opt : string -> char -> int option
val rindex : string -> char -> int
val rindex_opt : string -> char -> int option
val index_from : string -> int -> char -> int
val index_from_opt : string -> int -> char -> int option
val rindex_from : string -> int -> char -> int
val rindex_from_opt : string -> int -> char -> int option
val contains : string -> char -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
val uppercase_ascii : string -> string
val lowercase_ascii : string -> string
val capitalize_ascii : string -> string
val uncapitalize_ascii : string -> string
type t = string
val compare : t -> t -> int
val equal : t -> t -> bool
val split_on_char : char -> string -> string list
val to_seq : t -> char Stdlib.Seq.t
val to_seqi : t -> (int * char) Stdlib.Seq.t
val of_seq : char Stdlib.Seq.t -> t
val unsafe_get : string -> int -> char
val unsafe_set : bytes -> int -> char -> unit
val unsafe_blit : string -> int -> bytes -> int -> int -> unit
val unsafe_fill : bytes -> int -> int -> char -> unit
include module type of Prime_string

Construction and Conversion

val sample : (int -> char) -> int -> string

sample f n is the string of length n with s.[i] = f i for each i in range.

val of_chars : char list -> string

of_chars cs is the order-preserving concatenation of cs.

val to_chars : string -> char list

to_chars s is [s.[0]; ...; s.[n - 1]] where n = length s.

Iteration over Elements

val fold : (char -> 'a -> 'a) -> string -> 'a -> 'a

fold f s is f s.[n - 1] ∘ ... ∘ f s[0] where n = length s.

val foldi : (int -> char -> 'a -> 'a) -> string -> 'a -> 'a

foldi f s is f (n - 1) s.[n - 1] ∘ ... ∘ f 0 s[0] where n = length s.

val for_all : (char -> bool) -> string -> bool

for_all f s is f s.[0] && ... && f s.[n - 1].

val exists : (char -> bool) -> string -> bool

exists f s is f s.[0] || ... || f s.[n - 1].

val count : (char -> bool) -> string -> int

count f s is the number of occurrences of a characters in s which fulfil f.

val filter : (char -> bool) -> string -> string

filter f s is the string s with characters not fulfilling f edited out.

search f s is Some c where c is the first character in s which fulfils f, or None if there is no such c in s.

Search Primitives

val skip_while : (char -> bool) -> string -> int -> int

skip_while f s increments a position until it reaches the end of s or it points to a character in s on which f returns false. In other words if j = skip_while f s i, then slice i j s is the largest substring starting at i on which f is constant true.

val skip_until : (char -> bool) -> string -> int -> int

skip_until f is an optimisation of skip_while (not ∘ f).

val rskip_while : (char -> bool) -> string -> int -> int

rskip_while f s decrements a position as long as the result points to a character in s on which f is true.

val rskip_until : (char -> bool) -> string -> int -> int

rskip_until f is an optimization of rskip_while (not ∘ f).

val skip_affix : string -> string -> int -> int option

skip_affix afx s i returns the end position of the leftmost occurrence of afx in s which starts at or after i, or None if afx does not occur in slice i (length s) s.

val rskip_affix : string -> string -> int -> int option

rskip_affix afx s j retruns the start position of the rightmost occurrence of afx in s which ends before or at j or None if afx does not occur in slice 0 j s.

Substring Predicates

val has_prefix : string -> string -> bool

has_prefix pfx s is true iff s starts with pfx.

val has_suffix : string -> string -> bool

has_suffix sfx s is true iff s ends with sfx.

val has_slice : int -> string -> string -> bool

has_slice i ss s is true iff s contains the substring ss starting at position i.

Slicing

val slice : int -> int -> string -> string

slice i j s is the slice of s from position i up to but not including j.

val slice_from : int -> string -> string

slice_from i s is a shortcut for slice i (String.length s) s.

val cut_affix : string -> string -> (string * string) option

cut_affix afx s returns the substrings before and after the leftmost occurrence of afx in s or None if afx does not occur in s.

val rcut_affix : string -> string -> (string * string) option

rcut_affix afx s returns the substrings before and after the rightmost occurrence of afx in s or None if afx does not occur in s.

val chop_affix : string -> string -> string list

chop_affix afx s returns the substrings before, between, and after matches of afx in s, except for chop_affix afx "", which always gives []. In other words chop_affix afx provides a primitive way of extracting the operands of an infix operator afx. If afx can overlap, it is unspecified which match is used.

val cut_consecutive : (char -> bool) -> string -> (string * string) option

cut_consecutive f s returns the substrings before and after the leftmost consecutive sequence of bytes satisfying f, or None if not String.exists f s.

val rcut_consecutive : (char -> bool) -> string -> (string * string) option

cut_consecutive f s returns the substrings before and after the rightmost consecutive sequence of bytes satisfying f, or None if not String.exists f s.

val chop_consecutive : (char -> bool) -> string -> string list

chop_consecutive f s returns the non-empty substrings before, between, and after consecutive sequences of bytes c for which f c is true. In particular chop_consecutive Char.is_space is suitable for splitting words separated by ASCII white-spaces.