B00_std.String
Strings.
String
include module type of String
make n c
is a string of length n
with each index holding the character c
.
init n f
is a string of length n
with index i
holding the character f i
(called in increasing index order).
get s i
is the character at index i
in s
. This is the same as writing s.[i]
.
Note. The Stdlib
.( ^ ) binary operator concatenates two strings.
concat sep ss
concatenates the list of strings ss
, inserting the separator string sep
between each.
compare s0 s1
sorts s0
and s1
in lexicographical order. compare
behaves like Stdlib.compare
on strings but may be more efficient.
contains_from s start c
is true
if and only if c
appears in s
after position start
.
rcontains_from s stop c
is true
if and only if c
appears in s
before position stop+1
.
contains s c
is String.contains_from
s 0 c
.
sub s pos len
is a string of length len
, containing the substring of s
that starts at position pos
and has length len
.
split_on_char sep s
is the list of all (possibly empty) substrings of s
that are delimited by the character sep
.
The function's result is specified by the following invariants:
sep
as a separator returns a string equal to the input (concat (make 1 sep)
(split_on_char sep s) = s
).sep
character.map f s
is the string resulting from applying f
to all the characters of s
in increasing order.
mapi f s
is like map
but the index of the character is also passed to f
.
trim s
is s
without leading and trailing whitespace. Whitespace characters are: ' '
, '\x0C'
(form feed), '\n'
, '\r'
, and '\t'
.
escaped s
is s
with special characters represented by escape sequences, following the lexical conventions of OCaml.
All characters outside the US-ASCII printable range [0x20;0x7E] are escaped, as well as backslash (0x2F) and double-quote (0x22).
The function Scanf
.unescaped is a left inverse of escaped
, i.e. Scanf.unescaped (escaped s) = s
for any string s
(unless escaped s
fails).
uppercase_ascii s
is s
with all lowercase letters translated to uppercase, using the US-ASCII character set.
lowercase_ascii s
is s
with all uppercase letters translated to lowercase, using the US-ASCII character set.
capitalize_ascii s
is s
with the first character set to uppercase, using the US-ASCII character set.
uncapitalize_ascii s
is s
with the first character set to lowercase, using the US-ASCII character set.
iter f s
applies function f
in turn to all the characters of s
. It is equivalent to f s.[0]; f s.[1]; ...; f s.[length s - 1]; ()
.
iteri
is like iter
, but the function is also given the corresponding character index.
index_from s i c
is the index of the first occurrence of c
in s
after position i
.
index_from_opt s i c
is the index of the first occurrence of c
in s
after position i
(if any).
rindex_from s i c
is the index of the last occurrence of c
in s
before position i+1
.
rindex_from_opt s i c
is the index of the last occurrence of c
in s
before position i+1
(if any).
index s c
is String.index_from
s 0 c
.
index_opt s c
is String.index_from_opt
s 0 c
.
rindex s c
is String.rindex_from
s (length s - 1) c
.
rindex_opt s c
is String.rindex_from_opt
s (length s - 1) c
.
to_seq s
is a sequence made of the string's characters in increasing order. In "unsafe-string"
mode, modifications of the string during iteration will be reflected in the iterator.
to_seqi s
is like to_seq
but also tuples the corresponding index.
create n
returns a fresh byte sequence of length n
. The sequence is uninitialized and contains arbitrary bytes.
set s n c
modifies byte sequence s
in place, replacing the byte at index n
with c
. You can also write s.[n] <- c
instead of set s n c
.
blit src src_pos dst dst_pos len
copies len
bytes from the string src
, starting at index src_pos
, to byte sequence dst
, starting at character number dst_pos
.
fill s pos len c
modifies byte sequence s
in place, replacing len
bytes by c
, starting at pos
.
Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..
starts_with ~prefix s
is true
iff sub.[i] = s.[i]
for all indices i
of prefix
.
Note. Available in 4.12.
eds_with ~suffix s
is true iff sub.[i] = s.[m - i]
for all indices i
of sufix
and with m = String.length s - 1
.
Note. Available in 4.12.
includes ~affix s
is true
iff there exists an index j
such that for all indices i
of affix
, sub.[i] = s.[j+ 1]
.
for_all p s
is true
iff for all indices i
of s
, p s.[i]
= true
.
exists p s
is true
iff there exists an index i
of s
with p s.[i] = true
.
find_sub ~start ~sub s
is the start index (if any) of the first occurence of sub
in s
at or after start
.
subrange ~first ~last s
are the consecutive bytes of s
whose indices exist in the range [first
;last
].
first
defaults to 0
and last to String.length s - 1
.
Note that both first
and last
can be any integer. If first
> last
the interval is empty and the empty string is returned.
take_left n s
are the first n
bytes of s
. This is s
if n >= length s
and ""
if n <= 0
.
take_right n s
are the last n
bytes of s
. This is s
if n >= length s
and ""
if n <= 0
.
drop_left n s
is s
without the first n
bytes of s
. This is ""
if n >= length s
and s
if n <= 0
.
drop_right n s
is s
without the last n
bytes of s
. This is ""
if n >= length s
and s
if n <= 0
.
break_right n v
is (drop_left n v, take_right n v)
.
keep_left sat s
are the first consecutive sat
statisfying bytes of s
.
keep_right sat s
are the last consecutive sat
satisfying bytes of s
.
lose_left sat s
is s
without the first consecutive sat
satisfying bytes of s
.
lose_right sat s
is s
without the last consecutive sat
satisfying bytes of s
.
span_left sat s
is (keep_left sat s, lose_left sat s)
.
span_right sat s
is (lose_right sat s, keep_right sat s)
.
cut ~sep s
is either the pair Some (l,r)
of the two (possibly empty) substrings of s
that are delimited by the first match of the separator character sep
or None
if sep
can't be matched in s
. Matching starts from the left of s
.
The invariant l ^ sep ^ r = s
holds.
cut_right ~sep s
is like cut_left
but matching starts on the right of s
.
cuts_left sep s
is the list of all substrings of s
that are delimited by matches of the non empty separator string sep
. Empty substrings are omitted in the list if drop_empty
is true
(defaults to false
).
Matching separators in s
starts from the left of s
(rev
is false
, default) or the end (rev
is true
). Once one is found, the separator is skipped and matching starts again, that is separator matches can't overlap. If there is no separator match in s
, the list [s]
is returned.
The following invariants hold:
concat ~sep (cuts ~drop_empty:false ~sep s) = s
cuts ~drop_empty:false ~sep s <> []
cuts_right sep s
is like cuts_left
but matching starts on the right of s
.
val pp : string Fmt.t
pp ppf s
prints s
's bytes on ppf
.
val pp_dump : string Fmt.t
pp_dump ppf s
prints s
as a syntactically valid OCaml string on ppf
.
uniquify ss
is ss
without duplicates, the list order is preserved.
val unique : exists:(string -> bool) -> string -> (string, string) result
unique ~exist n
is n
if exists n
is false
or r = strf
"%s~%d" n d
with d
the smallest integer in [1
;1e9
] such that exists r
is false
or an error if there is no such string.
edit_distance s0 s1
is the number of single character edits (insertion, deletion, substitution) that are needed to change s0
into s1
.
suggest ~dist candidates s
are the elements of candidates
whose edit distance is the smallest to s
and at most at a distance of dist
of s
(defaults to 2
). If multiple results are returned the order of candidates
is preserved.
The following functions can only (un)escape a single byte. See also these functions to convert a string to printable US-ASCII characters.
byte_escaper char_len set_char
is a byte escaper such that:
char_len c
is the length of the unescaped byte c
in the escaped form. If 1
is returned then c
is assumed to be unchanged use byte_replacer
if that does not holdset_char b i c
sets an unescaped byte c
to its escaped form at index i
in b
and returns the next writable index. set_char
is called regardless if c
needs to be escaped or not in the latter case you must write c
(use byte_replacer
if that is not the case). No bounds check need to be performed on i
or the returned value.For any b
, c
and i
the invariant i + char_len c = set_char b i c
must hold.
Here's a small example that escapes '"'
by prefixing them by backslashes. double quotes from strings:
let escape_dquotes s =
let char_len = function '"' -> 2 | _ -> 1 in
let set_char b i = function
| '"' -> Bytes.set b i '\\'; Bytes.set b (i+1) '"'; i + 2
| c -> Bytes.set b i c; i + 1
in
String.byte_escaper char_len set_char s
byte_replacer char_len set_char
is like byte_escaper
but a byte can be substituted by another one by set_char
.
val byte_unescaper : (string -> int -> int) -> (bytes -> int -> string -> int -> int) -> string -> (string, int) result
byte_unescaper char_len_at set_char
is a byte unescaper such that:
char_len_at s i
is the length of an escaped byte at index i
of s
. If 1
is returned then the byte is assumed to be unchanged by the unescape, use byte_unreplace
if that does not hold.set_char b k s i
sets at index k
in b
the unescaped byte read at index i
in s
and returns the next readable index in s
. set_char
is called regardless of wheter the byte at i
must be unescaped or not in the latter case you must write s.i
only (use byte_unreplacer
if that is not the case). No bounds check need to be performed on k
, i
or the returned value.For any b
, s
, k
and i
the invariant i + char_len_at s i
= set_char b k s i
must hold.
Both char_len_at
and set_char
may raise Illegal_escape i
if the given index i
has an illegal or truncated escape. The unescaper turns this exception into Error i
if that happens.
val byte_unreplacer : (string -> int -> int) -> (bytes -> int -> string -> int -> int) -> string -> (string, int) result
byte_unreplacer char_len_at set_char
is like byte_unscaper
except set_char
can set a different byte whenever char_len_at
returns 1
.
module Ascii : sig ... end
US-ASCII string support.
to_version
parses version strings of the form:
"[v|V]major.minor[.patchlevel][(+|~)additional-info]"
into (major, minor, patch, additional_info)
tuples. If no patchlevel
is found 0
is used.
module Set : sig ... end
String sets.
module Map : sig ... end
String maps.