fold_result t ~init ~f is a short-circuiting version of fold that runs in the Result monad. If f returns an Error _, that value is returned without any additional invocations of f.
fold_until t ~init ~f ~finish is a short-circuiting version of fold. If f returns Stop _ the computation ceases and results in that value. If f returns Continue _, the fold will proceed. If f never returns Stop _, the final result is computed by finish.
Example:
type maybe_negative =
| Found_negative of int
| All_nonnegative of { sum : int }
(** [first_neg_or_sum list] returns the first negative number in [list], if any,
otherwise returns the sum of the list. *)
let first_neg_or_sum =
List.fold_until ~init:0
~f:(fun sum x ->
if x < 0
then Stop (Found_negative x)
else Continue (sum + x))
~finish:(fun sum -> All_nonnegative { sum })
;;
let x = first_neg_or_sum [1; 2; 3; 4; 5]
val x : maybe_negative = All_nonnegative {sum = 15}
let y = first_neg_or_sum [1; 2; -3; 4; 5]
val y : maybe_negative = Found_negative -3
val min_elt : string ->compare:(elt->elt-> int)->elt option
Returns a min (resp. max) element from the collection using the provided compare function. In case of a tie, the first element encountered while traversing the collection is returned. The implementation uses fold so it has the same complexity as fold. Returns None iff the collection is empty.
val max_elt : string ->compare:(elt->elt-> int)->elt option
These are all like their equivalents in Container except that an index starting at 0 is added as the first argument to f.
unsafe_get t i is like get t i but does not perform bounds checking. The caller must ensure that it is a memory-safe operation.
val make : int ->char -> string
val copy : string -> string
Assuming you haven't passed -unsafe-string to the compiler, strings are immutable, so there'd be no motivation to make a copy.
deprecated [since 2018-03] Use [Bytes.copy] instead
val init : int ->f:(int -> char)-> string
val (^) : string ->string -> string
String append. Also available unqualified, but re-exported here for documentation purposes.
Note that a ^ b must copy both a and b into a newly-allocated result string, so a ^ b ^ c ^ ... ^ z is quadratic in the number of strings. String.concat does not have this problem -- it allocates the result buffer only once.
val concat : ?sep:string ->string list-> string
Concatenates all strings in the list using separator sep (with a default separator "").
val escaped : string -> string
Special characters are represented by escape sequences, following the lexical conventions of OCaml.
val contains : ?pos:int ->?len:int ->string ->char -> bool
val uppercase : string -> string
Operates on the whole string using the US-ASCII character set, e.g. uppercase "foo" = "FOO".
val lowercase : string -> string
val capitalize : string -> string
Operates on just the first character using the US-ASCII character set, e.g. capitalize "foo" = "Foo".
val uncapitalize : string -> string
index gives the index of the first appearance of char in the string when searching from left to right, or None if it's not found. rindex does the same but searches from the right.
For example, String.index "Foo" 'o' is Some 1 while String.rindex "Foo" 'o' is Some 2.
The _exn versions return the actual index (instead of an option) when char is found, and raise Caml.Not_found or Not_found_s otherwise.
val index : string ->char ->int option
val index_exn : string ->char -> int
val index_from : string ->int ->char ->int option
val index_from_exn : string ->int ->char -> int
val rindex : string ->char ->int option
val rindex_exn : string ->char -> int
val rindex_from : string ->int ->char ->int option
Substring search and replace functions. They use the Knuth-Morris-Pratt algorithm (KMP) under the hood.
val substr_index : ?pos:int ->string ->pattern:string ->int option
Substring search and replace convenience functions. They call Search_pattern.create and then forget the preprocessed pattern when the search is complete. pos < 0 or pos >= length t result in no match (hence substr_index returns None and substr_index_exn raises). may_overlap indicates whether to report overlapping matches, see Search_pattern.index_all.
val substr_index_exn : ?pos:int ->string ->pattern:string -> int
val substr_index_all : string ->may_overlap:bool ->pattern:string ->int list
val substr_replace_first :
?pos:int ->string ->pattern:string ->with_:string ->
string
val substr_replace_all : string ->pattern:string ->with_:string -> string
As with Search_pattern.replace_all, the result may still contain pattern.
val is_substring : string ->substring:string -> bool
is_substring ~substring:"bar" "foo bar baz" is true.
val is_substring_at : string ->pos:int ->substring:string -> bool
is_substring_at "foo bar baz" ~pos:4 ~substring:"bar" is true.
val to_list_rev : string ->char list
Returns the reversed list of characters contained in a list.
val rev : string -> string
rev t returns t in reverse order.
val is_suffix : string ->suffix:string -> bool
is_suffix s ~suffix returns true if s ends with suffix.
val is_prefix : string ->prefix:string -> bool
is_prefix s ~prefix returns true if s starts with prefix.
val lsplit2_exn : string ->on:char -> string * string
If the string s contains the character on, then lsplit2_exn s ~on returns a pair containing s split around the first appearance of on (from the left). Raises Caml.Not_found or Not_found_s when on cannot be found in s.
val rsplit2_exn : string ->on:char -> string * string
If the string s contains the character on, then rsplit2_exn s ~on returns a pair containing s split around the first appearance of on (from the right). Raises Caml.Not_found or Not_found_s when on cannot be found in s.
val lsplit2 : string ->on:char ->(string * string) option
lsplit2 s ~on optionally returns s split into two strings around the first appearance of on from the left.
val rsplit2 : string ->on:char ->(string * string) option
rsplit2 s ~on optionally returns s split into two strings around the first appearance of on from the right.
val split : string ->on:char ->string list
split s ~on returns a list of substrings of s that are separated by on. Consecutive on characters will cause multiple empty strings in the result. Splitting the empty string returns a list of the empty string, not the empty list.
val split_on_chars : string ->on:char list->string list
split_on_chars s ~on returns a list of all substrings of s that are separated by one of the chars from on. on are not grouped. So a grouping of on in the source string will produce multiple empty string splits in the result.
val split_lines : string ->string list
split_lines t returns the list of lines that comprise t. The lines do not include the trailing "\n" or "\r\n".
val lfindi : ?pos:int ->string ->f:(int ->char -> bool)->int option
lfindi ?pos t ~f returns the smallest i >= pos such that f i t.[i], if there is such an i. By default, pos = 0.
val rfindi : ?pos:int ->string ->f:(int ->char -> bool)->int option
rfindi ?pos t ~f returns the largest i <= pos such that f i t.[i], if there is such an i. By default pos = length t - 1.
val lstrip : ?drop:(char -> bool)->string -> string
lstrip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the beginning of s.
val rstrip : ?drop:(char -> bool)->string -> string
rstrip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the end of s.
val strip : ?drop:(char -> bool)->string -> string
strip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the beginning and end of s.
val map : string ->f:(char -> char)-> string
val mapi : string ->f:(int ->char -> char)-> string
Like map, but passes each character's index to f along with the char.
val foldi : string ->init:'a->f:(int ->'a->char ->'a)->'a
foldi works similarly to fold, but also passes the index of each character to f.
val concat_map : ?sep:string ->string ->f:(char -> string)-> string
Like map, but allows the replacement of a single character with zero or two or more characters.
val filter : string ->f:(char -> bool)-> string
filter s ~f:predicate discards characters not satisfying predicate.
val filteri : string ->f:(int ->char -> bool)-> string
Like filter, but passes each character's index to f along with the char.
val tr : target:char ->replacement:char ->string -> string
tr ~target ~replacement s replaces every instance of target in s with replacement.
val tr_multi :
target:string ->replacement:string ->(string -> string)Base.Staged.t
tr_multi ~target ~replacement returns a function that replaces every instance of a character in target with the corresponding character in replacement.
If replacement is shorter than target, it is lengthened by repeating its last character. Empty replacement is illegal unless target also is.
If target contains multiple copies of the same character, the last corresponding replacement character is used. Note that character ranges are not supported, so ~target:"a-z" means the literal characters 'a', '-', and 'z'.
val chop_suffix_exn : string ->suffix:string -> string
chop_suffix_exn s ~suffix returns s without the trailing suffix, raising Invalid_argument if suffix is not a suffix of s.
val chop_prefix_exn : string ->prefix:string -> string
chop_prefix_exn s ~prefix returns s without the leading prefix, raising Invalid_argument if prefix is not a prefix of s.
val chop_suffix : string ->suffix:string ->string option
val chop_prefix : string ->prefix:string ->string option
val chop_suffix_if_exists : string ->suffix:string -> string
chop_suffix_if_exists s ~suffix returns s without the trailing suffix, or just s if suffix isn't a suffix of s.
Equivalent to chop_suffix s ~suffix |> Option.value ~default:s, but avoids allocating the intermediate option.
val chop_prefix_if_exists : string ->prefix:string -> string
chop_prefix_if_exists s ~prefix returns s without the leading prefix, or just s if prefix isn't a prefix of s.
Equivalent to chop_prefix s ~prefix |> Option.value ~default:s, but avoids allocating the intermediate option.
val suffix : string ->int -> string
suffix s n returns the longest suffix of s of length less than or equal to n.
val prefix : string ->int -> string
prefix s n returns the longest prefix of s of length less than or equal to n.
val drop_suffix : string ->int -> string
drop_suffix s n drops the longest suffix of s of length less than or equal to n.
val drop_prefix : string ->int -> string
drop_prefix s n drops the longest prefix of s of length less than or equal to n.
val common_suffix : string list-> string
Produces the longest common suffix, or "" if the list is empty.
val common_prefix : string list-> string
Produces the longest common prefix, or "" if the list is empty.
val common_suffix_length : string list-> int
Produces the length of the longest common suffix, or 0 if the list is empty.
val common_prefix_length : string list-> int
Produces the length of the longest common prefix, or 0 if the list is empty.
val common_suffix2 : string ->string -> string
Produces the longest common suffix.
val common_prefix2 : string ->string -> string
Produces the longest common prefix.
val common_suffix2_length : string ->string -> int
Produces the length of the longest common suffix.
val common_prefix2_length : string ->string -> int
Produces the length of the longest common prefix.
val concat_array : ?sep:string ->string array-> string
concat_array sep ar like String.concat, but operates on arrays.
Operations for escaping and unescaping strings, with parameterized escape and escapeworthy characters. Escaping/unescaping using this module is more efficient than using Pcre. Benchmark code can be found in core/benchmarks/string_escaping.ml.
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.
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.
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.
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.
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.