Module Ocamlformat_stdlib.StringSource

Interface for Unicode encodings, such as UTF-8. Written with an abstract type, and specialized below.

Iterface for Unicode encodings, specialized for string representation.

sub with no bounds checking, and always returns a new copy

Maximum length of a string.

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.

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.

Concatenates all strings in the list using separator sep (with a default separator "").

Special characters are represented by escape sequences, following the lexical conventions of OCaml.

Operates on the whole string using the US-ASCII character set, e.g. uppercase "foo" = "FOO".

Operates on the whole string using the US-ASCII character set, e.g. lowercase "FOO" = "foo".

Operates on just the first character using the US-ASCII character set, e.g. capitalize "foo" = "Foo".

Caseless compares and hashes strings ignoring case, so that for example Caseless.equal "OCaml" "ocaml" and Caseless.("apple" < "Banana") are true.

Produce a sequence of the characters in a string.

Read the characters in a full sequence and produce a string.

Substring search and replace functions. They use the Knuth-Morris-Pratt algorithm (KMP) under the hood.

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.

As with Search_pattern.replace_all, the result may still contain pattern.

is_substring ~substring:"bar" "foo bar baz" is true.

is_substring_at "foo bar baz" ~pos:4 ~substring:"bar" is true.

Returns the reversed list of characters contained in a list.

rev t returns t in reverse order.

is_suffix s ~suffix returns true if s ends with suffix.

is_prefix s ~prefix returns true if s starts with prefix.

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 Stdlib.Not_found or Not_found_s when on cannot be found in s.

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 Stdlib.Not_found or Not_found_s when on cannot be found in s.

lsplit2 s ~on optionally returns s split into two strings around the first appearance of on from the left.

rsplit2 s ~on optionally returns s split into two strings around the first appearance of on from the right.

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.

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.

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.

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.

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.

split_lines t returns the list of lines that comprise t. The lines do not include the trailing "\n" or "\r\n".

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.

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.

Like map, but allows the replacement of a single character with zero or two or more characters.

tr ~target ~replacement s replaces every instance of target in s with replacement.

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

chop_suffix_exn s ~suffix returns s without the trailing suffix, raising Invalid_argument if suffix is not a suffix of s.

chop_prefix_exn s ~prefix returns s without the leading prefix, raising Invalid_argument if prefix is not a prefix of s.

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.

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.

suffix s n returns the longest suffix of s of length less than or equal to n.

prefix s n returns the longest prefix of s of length less than or equal to n.

drop_suffix s n drops the longest suffix of s of length less than or equal to n.

drop_prefix s n drops the longest prefix of s of length less than or equal to n.

Produces the longest common suffix, or "" if the list is empty.

Produces the longest common prefix, or "" if the list is empty.

Produces the length of the longest common suffix, or 0 if the list is empty.

Produces the length of the longest common prefix, or 0 if the list is empty.

Produces the longest common suffix.

Produces the longest common prefix.

Produces the length of the longest common suffix.

Produces the length of the longest common prefix.

concat_array sep ar like String.concat, but operates on arrays.

Builds a multiline text from a list of lines. Each line is terminated and then concatenated.

  # String.concat_lines ["one two"; "three four"; "five"]
  - : string = "one two\nthree four\nfive\n"
  # String.concat_lines ~crlf:true ["one two"; "three four"; "five"]
  - : string = "one two\r\nthree four\r\nfive\r\n"

Slightly faster hash function on strings.

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

pad_right ?char ~s len returns s padded to the length len by adding characters char to the end of the string. If s is already longer than len it is returned unchanged.

Reports the Levenshtein edit distance between two strings. Computes the minimum number of single-character insertions, deletions, and substitutions needed to transform one into the other.

For strings of length M and N, its time complexity is O(M*N) and its space complexity is O(min(M,N)).

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.

UTF-8 encoding. See Utf interface.

UTF-16 little-endian encoding. See Utf interface.

UTF-16 big-endian encoding. See Utf interface.

UTF-32 little-endian encoding. See Utf interface.

UTF-32 big-endian encoding. See Utf interface.