module String: StringLabels;
type t = string;
The type for strings.
let make: (int, char) => string;
make n c
is a string of length n
with each index holding the
character c
.
Invalid_argument
if n < 0
or n >
Sys.max_string_length
.let init: (int, ~f: int => char) => string;
init n ~f
is a string of length n
with index
i
holding the character f i
(called in increasing index order).
Invalid_argument
if n < 0
or n >
Sys.max_string_length
.let length: string => int;
length s
is the length (number of bytes/characters) of s
.
let get: (string, int) => char;
get s i
is the character at index i
in s
. This is the same
as writing s.[i]
.
Invalid_argument
if i
not an index of s
.Note. The (^)
binary operator concatenates two
strings.
let concat: (~sep: string, list(string)) => string;
concat ~sep ss
concatenates the list of strings ss
, inserting
the separator string sep
between each.
Invalid_argument
if the result is longer than
Sys.max_string_length
bytes.let equal: (t, t) => bool;
equal s0 s1
is true
if and only if s0
and s1
are character-wise
equal.
let compare: (t, t) => int;
compare s0 s1
sorts s0
and s1
in lexicographical order. compare
behaves like compare
on strings but may be more efficient.
let contains_from: (string, int, char) => bool;
contains_from s start c
is true
if and only if c
appears in s
after position start
.
Invalid_argument
if start
is not a valid position in s
.let rcontains_from: (string, int, char) => bool;
rcontains_from s stop c
is true
if and only if c
appears in s
before position stop+1
.
Invalid_argument
if stop < 0
or stop+1
is not a valid
position in s
.let contains: (string, char) => bool;
contains s c
is String.contains_from
s 0 c
.
let sub: (string, ~pos: int, ~len: int) => string;
sub s ~pos ~len
is a string of length len
, containing the
substring of s
that starts at position pos
and has length
len
.
Invalid_argument
if pos
and len
do not designate a valid
substring of s
.let split_on_char: (~sep: char, string) => list(string);
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.let map: (~f: char => char, string) => string;
map f s
is the string resulting from applying f
to all the
characters of s
in increasing order.
let mapi: (~f: (int, char) => char, string) => string;
mapi ~f s
is like StringLabels.map
but the index of the character is also
passed to f
.
let trim: string => string;
trim s
is s
without leading and trailing whitespace. Whitespace
characters are: ' '
, '\x0C'
(form feed), '\n'
, '\r'
, and '\t'
.
let escaped: string => string;
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).
Invalid_argument
if the result is longer than
Sys.max_string_length
bytes.let uppercase_ascii: string => string;
uppercase_ascii s
is s
with all lowercase letters
translated to uppercase, using the US-ASCII character set.
let lowercase_ascii: string => string;
lowercase_ascii s
is s
with all uppercase letters translated
to lowercase, using the US-ASCII character set.
let capitalize_ascii: string => string;
capitalize_ascii s
is s
with the first character set to
uppercase, using the US-ASCII character set.
let uncapitalize_ascii: string => string;
uncapitalize_ascii s
is s
with the first character set to lowercase,
using the US-ASCII character set.
let iter: (~f: char => unit, string) => unit;
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]; ()
.
let iteri: (~f: (int, char) => unit, string) => unit;
iteri
is like StringLabels.iter
, but the function is also given the
corresponding character index.
let index_from: (string, int, char) => int;
index_from s i c
is the index of the first occurrence of c
in
s
after position i
.
Not_found
if c
does not occur in s
after position i
.Invalid_argument
if i
is not a valid position in s
.let index_from_opt: (string, int, char) => option(int);
index_from_opt s i c
is the index of the first occurrence of c
in s
after position i
(if any).
Invalid_argument
if i
is not a valid position in s
.let rindex_from: (string, int, char) => int;
rindex_from s i c
is the index of the last occurrence of c
in
s
before position i+1
.
Not_found
if c
does not occur in s
before position i+1
.Invalid_argument
if i+1
is not a valid position in s
.let rindex_from_opt: (string, int, char) => option(int);
rindex_from_opt s i c
is the index of the last occurrence of c
in s
before position i+1
(if any).
Invalid_argument
if i+1
is not a valid position in s
.let index: (string, char) => int;
index s c
is String.index_from
s 0 c
.
let index_opt: (string, char) => option(int);
index_opt s c
is String.index_from_opt
s 0 c
.
let rindex: (string, char) => int;
rindex s c
is String.rindex_from
s (length s - 1) c
.
let rindex_opt: (string, char) => option(int);
rindex_opt s c
is String.rindex_from_opt
s (length s - 1) c
.
let to_seq: t => Seq.t(char);
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.
let to_seqi: t => Seq.t((int, char));
to_seqi s
is like StringLabels.to_seq
but also tuples the corresponding index.
let of_seq: Seq.t(char) => t;
of_seq s
is a string made of the sequence's characters.
let create: int => bytes;
create n
returns a fresh byte sequence of length n
.
The sequence is uninitialized and contains arbitrary bytes.
Invalid_argument
if n < 0
or n >
Sys.max_string_length
.let set: (bytes, int, char) => unit;
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
.
Invalid_argument
if n
is not a valid index in s
.let blit:
(~src: string, ~src_pos: int, ~dst: bytes, ~dst_pos: int, ~len: int) => unit;
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
.
Invalid_argument
if src_pos
and len
do not
designate a valid range of src
, or if dst_pos
and len
do not designate a valid range of dst
.let copy: string => string;
Return a copy of the given string.
let fill: (bytes, ~pos: int, ~len: int, char) => unit;
fill s ~pos ~len c
modifies byte sequence s
in place,
replacing len
bytes by c
, starting at pos
.
Invalid_argument
if pos
and len
do not
designate a valid substring of s
.let uppercase: string => string;
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.
let lowercase: string => string;
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.
let capitalize: string => string;
Return a copy of the argument, with the first character set to uppercase, using the ISO Latin-1 (8859-1) character set..
let uncapitalize: string => string;
Return a copy of the argument, with the first character set to lowercase, using the ISO Latin-1 (8859-1) character set.