File: String.html

package info (click to toggle)
ocaml-doc 4.11-2
links: PTS, VCS
area: non-free
in suites: bookworm, bullseye, forky, sid, trixie
size: 20,580 kB
sloc: sh: 37; makefile: 11
file content (600 lines) | stat: -rw-r--r-- 35,858 bytes
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="Start" href="index.html">
<link rel="previous" href="Stream.html">
<link rel="next" href="StringLabels.html">
<link rel="Up" href="index.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of extensions" rel=Appendix href="index_extensions.html">
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
<link title="Index of values" rel=Appendix href="index_values.html">
<link title="Index of modules" rel=Appendix href="index_modules.html">
<link title="Index of module types" rel=Appendix href="index_module_types.html">
<link title="Arg" rel="Chapter" href="Arg.html">
<link title="Array" rel="Chapter" href="Array.html">
<link title="ArrayLabels" rel="Chapter" href="ArrayLabels.html">
<link title="Bigarray" rel="Chapter" href="Bigarray.html">
<link title="Bool" rel="Chapter" href="Bool.html">
<link title="Buffer" rel="Chapter" href="Buffer.html">
<link title="Bytes" rel="Chapter" href="Bytes.html">
<link title="BytesLabels" rel="Chapter" href="BytesLabels.html">
<link title="Callback" rel="Chapter" href="Callback.html">
<link title="CamlinternalFormat" rel="Chapter" href="CamlinternalFormat.html">
<link title="CamlinternalFormatBasics" rel="Chapter" href="CamlinternalFormatBasics.html">
<link title="CamlinternalLazy" rel="Chapter" href="CamlinternalLazy.html">
<link title="CamlinternalMod" rel="Chapter" href="CamlinternalMod.html">
<link title="CamlinternalOO" rel="Chapter" href="CamlinternalOO.html">
<link title="Char" rel="Chapter" href="Char.html">
<link title="Complex" rel="Chapter" href="Complex.html">
<link title="Condition" rel="Chapter" href="Condition.html">
<link title="Digest" rel="Chapter" href="Digest.html">
<link title="Dynlink" rel="Chapter" href="Dynlink.html">
<link title="Ephemeron" rel="Chapter" href="Ephemeron.html">
<link title="Event" rel="Chapter" href="Event.html">
<link title="Filename" rel="Chapter" href="Filename.html">
<link title="Float" rel="Chapter" href="Float.html">
<link title="Format" rel="Chapter" href="Format.html">
<link title="Fun" rel="Chapter" href="Fun.html">
<link title="Gc" rel="Chapter" href="Gc.html">
<link title="Genlex" rel="Chapter" href="Genlex.html">
<link title="Hashtbl" rel="Chapter" href="Hashtbl.html">
<link title="Int" rel="Chapter" href="Int.html">
<link title="Int32" rel="Chapter" href="Int32.html">
<link title="Int64" rel="Chapter" href="Int64.html">
<link title="Lazy" rel="Chapter" href="Lazy.html">
<link title="Lexing" rel="Chapter" href="Lexing.html">
<link title="List" rel="Chapter" href="List.html">
<link title="ListLabels" rel="Chapter" href="ListLabels.html">
<link title="Map" rel="Chapter" href="Map.html">
<link title="Marshal" rel="Chapter" href="Marshal.html">
<link title="MoreLabels" rel="Chapter" href="MoreLabels.html">
<link title="Mutex" rel="Chapter" href="Mutex.html">
<link title="Nativeint" rel="Chapter" href="Nativeint.html">
<link title="Obj" rel="Chapter" href="Obj.html">
<link title="Ocaml_operators" rel="Chapter" href="Ocaml_operators.html">
<link title="Oo" rel="Chapter" href="Oo.html">
<link title="Option" rel="Chapter" href="Option.html">
<link title="Parsing" rel="Chapter" href="Parsing.html">
<link title="Printexc" rel="Chapter" href="Printexc.html">
<link title="Printf" rel="Chapter" href="Printf.html">
<link title="Queue" rel="Chapter" href="Queue.html">
<link title="Random" rel="Chapter" href="Random.html">
<link title="Result" rel="Chapter" href="Result.html">
<link title="Scanf" rel="Chapter" href="Scanf.html">
<link title="Seq" rel="Chapter" href="Seq.html">
<link title="Set" rel="Chapter" href="Set.html">
<link title="Spacetime" rel="Chapter" href="Spacetime.html">
<link title="Stack" rel="Chapter" href="Stack.html">
<link title="StdLabels" rel="Chapter" href="StdLabels.html">
<link title="Stdlib" rel="Chapter" href="Stdlib.html">
<link title="Str" rel="Chapter" href="Str.html">
<link title="Stream" rel="Chapter" href="Stream.html">
<link title="String" rel="Chapter" href="String.html">
<link title="StringLabels" rel="Chapter" href="StringLabels.html">
<link title="Sys" rel="Chapter" href="Sys.html">
<link title="Thread" rel="Chapter" href="Thread.html">
<link title="ThreadUnix" rel="Chapter" href="ThreadUnix.html">
<link title="Uchar" rel="Chapter" href="Uchar.html">
<link title="Unit" rel="Chapter" href="Unit.html">
<link title="Unix" rel="Chapter" href="Unix.html">
<link title="UnixLabels" rel="Chapter" href="UnixLabels.html">
<link title="Weak" rel="Chapter" href="Weak.html"><link title="Iterators" rel="Section" href="#1_Iterators">
<title>String</title>
</head>
<body>
<div class="navbar"><a class="pre" href="Stream.html" title="Stream">Previous</a>
&nbsp;<a class="up" href="index.html" title="Index">Up</a>
&nbsp;<a class="post" href="StringLabels.html" title="StringLabels">Next</a>
</div>
<h1>Module <a href="type_String.html">String</a></h1>

<pre><span id="MODULEString"><span class="keyword">module</span> String</span>: <code class="code"><span class="keyword">sig</span></code> <a href="String.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info module top">
<div class="info-desc">
<p>String operations.</p>

<p>A string is an immutable data structure that contains a
  fixed-length sequence of (single-byte) characters. Each character
  can be accessed in constant time through its index.</p>

<p>Given a string <code class="code">s</code> of length <code class="code">l</code>, we can access each of the <code class="code">l</code>
  characters of <code class="code">s</code> via its index in the sequence. Indexes start at
  <code class="code">0</code>, and we will call an index valid in <code class="code">s</code> if it falls within the
  range <code class="code">[0...l-1]</code> (inclusive). A position is the point between two
  characters or at the beginning or end of the string.  We call a
  position valid in <code class="code">s</code> if it falls within the range <code class="code">[0...l]</code>
  (inclusive). Note that the character at index <code class="code">n</code> is between
  positions <code class="code">n</code> and <code class="code">n+1</code>.</p>

<p>Two parameters <code class="code">start</code> and <code class="code">len</code> are said to designate a valid
  substring of <code class="code">s</code> if <code class="code">len&nbsp;&gt;=&nbsp;0</code> and <code class="code">start</code> and <code class="code">start+len</code> are
  valid positions in <code class="code">s</code>.</p>

<p>Note: OCaml strings used to be modifiable in place, for instance via
  the <a href="String.html#VALset"><code class="code"><span class="constructor">String</span>.set</code></a> and <a href="String.html#VALblit"><code class="code"><span class="constructor">String</span>.blit</code></a> functions described below. This
  usage is only possible when the compiler is put in "unsafe-string"
  mode by giving the <code class="code">-unsafe-string</code> command-line option. This
  compatibility mode makes the types <code class="code">string</code> and <code class="code">bytes</code> (see module
  <a href="Bytes.html"><code class="code"><span class="constructor">Bytes</span></code></a>) interchangeable so that functions expecting byte sequences
  can also accept strings as arguments and modify them.</p>

<p>The distinction between <code class="code">bytes</code> and <code class="code">string</code> was introduced in OCaml
  4.02, and the "unsafe-string" compatibility mode was the default
  until OCaml 4.05. Starting with 4.06, the compatibility mode is
  opt-in; we intend to remove the option in the future.</p>
</div>
</div>
<hr width="100%">

<pre><span id="VALlength"><span class="keyword">val</span> length</span> : <code class="type">string -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Return the length (number of characters) of the given string.</p>
</div>
</div>

<pre><span id="VALget"><span class="keyword">val</span> get</span> : <code class="type">string -> int -> char</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.get&nbsp;s&nbsp;n</code> returns the character at index <code class="code">n</code> in string <code class="code">s</code>.
   You can also write <code class="code">s.[n]</code> instead of <code class="code"><span class="constructor">String</span>.get&nbsp;s&nbsp;n</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">n</code> not a valid index in <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALset"><span class="keyword">val</span> set</span> : <code class="type">bytes -> int -> char -> unit</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>This is a deprecated alias of <a href="Bytes.html#VALset"><code class="code"><span class="constructor">Bytes</span>.set</code></a>.<code class="code">&nbsp;</code></div>
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.set&nbsp;s&nbsp;n&nbsp;c</code> modifies byte sequence <code class="code">s</code> in place,
   replacing the byte at index <code class="code">n</code> with <code class="code">c</code>.
   You can also write <code class="code">s.[n]&nbsp;&lt;-&nbsp;c</code> instead of <code class="code"><span class="constructor">String</span>.set&nbsp;s&nbsp;n&nbsp;c</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">n</code> is not a valid index in <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALcreate"><span class="keyword">val</span> create</span> : <code class="type">int -> bytes</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>This is a deprecated alias of <a href="Bytes.html#VALcreate"><code class="code"><span class="constructor">Bytes</span>.create</code></a>.<code class="code">&nbsp;</code></div>
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.create&nbsp;n</code> returns a fresh byte sequence of length <code class="code">n</code>.
   The sequence is uninitialized and contains arbitrary bytes.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">n&nbsp;&lt;&nbsp;0</code> or <code class="code">n&nbsp;&gt;&nbsp;</code><a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a>.</li>
</ul>
</div>

<pre><span id="VALmake"><span class="keyword">val</span> make</span> : <code class="type">int -> char -> string</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.make&nbsp;n&nbsp;c</code> returns a fresh string of length <code class="code">n</code>,
   filled with the character <code class="code">c</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">n&nbsp;&lt;&nbsp;0</code> or <code class="code">n&nbsp;&gt;&nbsp;</code><a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a>.</li>
</ul>
</div>

<pre><span id="VALinit"><span class="keyword">val</span> init</span> : <code class="type">int -> (int -> char) -> string</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.init&nbsp;n&nbsp;f</code> returns a string of length <code class="code">n</code>, with character
    <code class="code">i</code> initialized to the result of <code class="code">f&nbsp;i</code> (called in increasing
    index order).</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.02.0</li>
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">n&nbsp;&lt;&nbsp;0</code> or <code class="code">n&nbsp;&gt;&nbsp;</code><a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a>.</li>
</ul>
</div>

<pre><span id="VALcopy"><span class="keyword">val</span> copy</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>Because strings are immutable, it doesn't make much
    sense to make identical copies of them.</div>
<div class="info-desc">
<p>Return a copy of the given string.</p>
</div>
</div>

<pre><span id="VALsub"><span class="keyword">val</span> sub</span> : <code class="type">string -> int -> int -> string</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.sub&nbsp;s&nbsp;start&nbsp;len</code> returns a fresh string of length <code class="code">len</code>,
   containing the substring of <code class="code">s</code> that starts at position <code class="code">start</code> and
   has length <code class="code">len</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">start</code> and <code class="code">len</code> do not
   designate a valid substring of <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALfill"><span class="keyword">val</span> fill</span> : <code class="type">bytes -> int -> int -> char -> unit</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>This is a deprecated alias of <a href="Bytes.html#VALfill"><code class="code"><span class="constructor">Bytes</span>.fill</code></a>.<code class="code">&nbsp;</code></div>
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.fill&nbsp;s&nbsp;start&nbsp;len&nbsp;c</code> modifies byte sequence <code class="code">s</code> in place,
   replacing <code class="code">len</code> bytes with <code class="code">c</code>, starting at <code class="code">start</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">start</code> and <code class="code">len</code> do not
   designate a valid range of <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALblit"><span class="keyword">val</span> blit</span> : <code class="type">string -> int -> bytes -> int -> int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Same as <a href="Bytes.html#VALblit_string"><code class="code"><span class="constructor">Bytes</span>.blit_string</code></a>.</p>
</div>
</div>

<pre><span id="VALconcat"><span class="keyword">val</span> concat</span> : <code class="type">string -> string list -> string</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.concat&nbsp;sep&nbsp;sl</code> concatenates the list of strings <code class="code">sl</code>,
    inserting the separator string <code class="code">sep</code> between each.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if the result is longer than
    <a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a> bytes.</li>
</ul>
</div>

<pre><span id="VALiter"><span class="keyword">val</span> iter</span> : <code class="type">(char -> unit) -> string -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.iter&nbsp;f&nbsp;s</code> applies function <code class="code">f</code> in turn to all
   the characters of <code class="code">s</code>.  It is equivalent to
   <code class="code">f&nbsp;s.[0];&nbsp;f&nbsp;s.[1];&nbsp;...;&nbsp;f&nbsp;s.[<span class="constructor">String</span>.length&nbsp;s&nbsp;-&nbsp;1];&nbsp;()</code>.</p>
</div>
</div>

<pre><span id="VALiteri"><span class="keyword">val</span> iteri</span> : <code class="type">(int -> char -> unit) -> string -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Same as <a href="String.html#VALiter"><code class="code"><span class="constructor">String</span>.iter</code></a>, but the
   function is applied to the index of the element as first argument
   (counting from 0), and the character itself as second argument.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.00.0</li>
</ul>
</div>

<pre><span id="VALmap"><span class="keyword">val</span> map</span> : <code class="type">(char -> char) -> string -> string</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.map&nbsp;f&nbsp;s</code> applies function <code class="code">f</code> in turn to all the
    characters of <code class="code">s</code> (in increasing index order) and stores the
    results in a new string that is returned.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.00.0</li>
</ul>
</div>

<pre><span id="VALmapi"><span class="keyword">val</span> mapi</span> : <code class="type">(int -> char -> char) -> string -> string</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.mapi&nbsp;f&nbsp;s</code> calls <code class="code">f</code> with each character of <code class="code">s</code> and its
    index (in increasing index order) and stores the results in a new
    string that is returned.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.02.0</li>
</ul>
</div>

<pre><span id="VALtrim"><span class="keyword">val</span> trim</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, without leading and trailing
   whitespace.  The characters regarded as whitespace are: <code class="code"><span class="string">'&nbsp;'</span></code>,
   <code class="code"><span class="string">'\012'</span></code>, <code class="code"><span class="string">'\n'</span></code>, <code class="code"><span class="string">'\r'</span></code>, and <code class="code"><span class="string">'\t'</span></code>.  If there is neither leading nor
   trailing whitespace character in the argument, return the original
   string itself, not a copy.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.00.0</li>
</ul>
</div>

<pre><span id="VALescaped"><span class="keyword">val</span> escaped</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with special characters
    represented by escape sequences, following the lexical
    conventions of OCaml.
    All characters outside the ASCII printable range (32..126) are
    escaped, as well as backslash and double-quote.</p>

<p>If there is no special character in the argument that needs
    escaping, return the original string itself, not a copy.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if the result is longer than
    <a href="Sys.html#VALmax_string_length"><code class="code"><span class="constructor">Sys</span>.max_string_length</code></a> bytes.

    The function <a href="Scanf.html#VALunescaped"><code class="code"><span class="constructor">Scanf</span>.unescaped</code></a> is a left inverse of <code class="code">escaped</code>,
    i.e. <code class="code"><span class="constructor">Scanf</span>.unescaped&nbsp;(escaped&nbsp;s)&nbsp;=&nbsp;s</code> for any string <code class="code">s</code> (unless
    <code class="code">escape&nbsp;s</code> fails).</li>
</ul>
</div>

<pre><span id="VALindex"><span class="keyword">val</span> index</span> : <code class="type">string -> char -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.index&nbsp;s&nbsp;c</code> returns the index of the first
   occurrence of character <code class="code">c</code> in string <code class="code">s</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Not_found</code> if <code class="code">c</code> does not occur in <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALindex_opt"><span class="keyword">val</span> index_opt</span> : <code class="type">string -> char -> int option</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.index_opt&nbsp;s&nbsp;c</code> returns the index of the first
    occurrence of character <code class="code">c</code> in string <code class="code">s</code>, or
    <code class="code"><span class="constructor">None</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05</li>
</ul>
</div>

<pre><span id="VALrindex"><span class="keyword">val</span> rindex</span> : <code class="type">string -> char -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.rindex&nbsp;s&nbsp;c</code> returns the index of the last
   occurrence of character <code class="code">c</code> in string <code class="code">s</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Not_found</code> if <code class="code">c</code> does not occur in <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALrindex_opt"><span class="keyword">val</span> rindex_opt</span> : <code class="type">string -> char -> int option</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.rindex_opt&nbsp;s&nbsp;c</code> returns the index of the last occurrence
    of character <code class="code">c</code> in string <code class="code">s</code>, or <code class="code"><span class="constructor">None</span></code> if <code class="code">c</code> does not occur in
    <code class="code">s</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05</li>
</ul>
</div>

<pre><span id="VALindex_from"><span class="keyword">val</span> index_from</span> : <code class="type">string -> int -> char -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.index_from&nbsp;s&nbsp;i&nbsp;c</code> returns the index of the
   first occurrence of character <code class="code">c</code> in string <code class="code">s</code> after position <code class="code">i</code>.
   <code class="code"><span class="constructor">String</span>.index&nbsp;s&nbsp;c</code> is equivalent to <code class="code"><span class="constructor">String</span>.index_from&nbsp;s&nbsp;0&nbsp;c</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b><ul><li><code>Invalid_argument</code> if <code class="code">i</code> is not a valid position in <code class="code">s</code>.</li>
<li><code>Not_found</code> if <code class="code">c</code> does not occur in <code class="code">s</code> after position <code class="code">i</code>.</li>
</ul></li>
</ul>
</div>

<pre><span id="VALindex_from_opt"><span class="keyword">val</span> index_from_opt</span> : <code class="type">string -> int -> char -> int option</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.index_from_opt&nbsp;s&nbsp;i&nbsp;c</code> returns the index of the
    first occurrence of character <code class="code">c</code> in string <code class="code">s</code> after position <code class="code">i</code>
    or <code class="code"><span class="constructor">None</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code> after position <code class="code">i</code>.</p>

<p><code class="code"><span class="constructor">String</span>.index_opt&nbsp;s&nbsp;c</code> is equivalent to <code class="code"><span class="constructor">String</span>.index_from_opt&nbsp;s&nbsp;0&nbsp;c</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05</li>
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">i</code> is not a valid position in <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALrindex_from"><span class="keyword">val</span> rindex_from</span> : <code class="type">string -> int -> char -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.rindex_from&nbsp;s&nbsp;i&nbsp;c</code> returns the index of the
   last occurrence of character <code class="code">c</code> in string <code class="code">s</code> before position <code class="code">i+1</code>.
   <code class="code"><span class="constructor">String</span>.rindex&nbsp;s&nbsp;c</code> is equivalent to
   <code class="code"><span class="constructor">String</span>.rindex_from&nbsp;s&nbsp;(<span class="constructor">String</span>.length&nbsp;s&nbsp;-&nbsp;1)&nbsp;c</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b><ul><li><code>Invalid_argument</code> if <code class="code">i+1</code> is not a valid position in <code class="code">s</code>.</li>
<li><code>Not_found</code> if <code class="code">c</code> does not occur in <code class="code">s</code> before position <code class="code">i+1</code>.</li>
</ul></li>
</ul>
</div>

<pre><span id="VALrindex_from_opt"><span class="keyword">val</span> rindex_from_opt</span> : <code class="type">string -> int -> char -> int option</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.rindex_from_opt&nbsp;s&nbsp;i&nbsp;c</code> returns the index of the
   last occurrence of character <code class="code">c</code> in string <code class="code">s</code> before position <code class="code">i+1</code>
   or <code class="code"><span class="constructor">None</span></code> if <code class="code">c</code> does not occur in <code class="code">s</code> before position <code class="code">i+1</code>.</p>

<p><code class="code"><span class="constructor">String</span>.rindex_opt&nbsp;s&nbsp;c</code> is equivalent to
   <code class="code"><span class="constructor">String</span>.rindex_from_opt&nbsp;s&nbsp;(<span class="constructor">String</span>.length&nbsp;s&nbsp;-&nbsp;1)&nbsp;c</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05</li>
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">i+1</code> is not a valid position in <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALcontains"><span class="keyword">val</span> contains</span> : <code class="type">string -> char -> bool</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.contains&nbsp;s&nbsp;c</code> tests if character <code class="code">c</code>
   appears in the string <code class="code">s</code>.</p>
</div>
</div>

<pre><span id="VALcontains_from"><span class="keyword">val</span> contains_from</span> : <code class="type">string -> int -> char -> bool</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.contains_from&nbsp;s&nbsp;start&nbsp;c</code> tests if character <code class="code">c</code>
   appears in <code class="code">s</code> after position <code class="code">start</code>.
   <code class="code"><span class="constructor">String</span>.contains&nbsp;s&nbsp;c</code> is equivalent to
   <code class="code"><span class="constructor">String</span>.contains_from&nbsp;s&nbsp;0&nbsp;c</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">start</code> is not a valid position in <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALrcontains_from"><span class="keyword">val</span> rcontains_from</span> : <code class="type">string -> int -> char -> bool</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.rcontains_from&nbsp;s&nbsp;stop&nbsp;c</code> tests if character <code class="code">c</code>
   appears in <code class="code">s</code> before position <code class="code">stop+1</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</code> if <code class="code">stop&nbsp;&lt;&nbsp;0</code> or <code class="code">stop+1</code> is not a valid
   position in <code class="code">s</code>.</li>
</ul>
</div>

<pre><span id="VALuppercase"><span class="keyword">val</span> uppercase</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>Functions operating on Latin-1 character set are deprecated.</div>
<div class="info-desc">
<p>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.</p>
</div>
</div>

<pre><span id="VALlowercase"><span class="keyword">val</span> lowercase</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>Functions operating on Latin-1 character set are deprecated.</div>
<div class="info-desc">
<p>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.</p>
</div>
</div>

<pre><span id="VALcapitalize"><span class="keyword">val</span> capitalize</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>Functions operating on Latin-1 character set are deprecated.</div>
<div class="info-desc">
<p>Return a copy of the argument, with the first character set to uppercase,
   using the ISO Latin-1 (8859-1) character set..</p>
</div>
</div>

<pre><span id="VALuncapitalize"><span class="keyword">val</span> uncapitalize</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span>Functions operating on Latin-1 character set are deprecated.</div>
<div class="info-desc">
<p>Return a copy of the argument, with the first character set to lowercase,
   using the ISO Latin-1 (8859-1) character set..</p>
</div>
</div>

<pre><span id="VALuppercase_ascii"><span class="keyword">val</span> uppercase_ascii</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with all lowercase letters
   translated to uppercase, using the US-ASCII character set.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="VALlowercase_ascii"><span class="keyword">val</span> lowercase_ascii</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with all uppercase letters
   translated to lowercase, using the US-ASCII character set.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="VALcapitalize_ascii"><span class="keyword">val</span> capitalize_ascii</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with the first character set to uppercase,
   using the US-ASCII character set.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="VALuncapitalize_ascii"><span class="keyword">val</span> uncapitalize_ascii</span> : <code class="type">string -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Return a copy of the argument, with the first character set to lowercase,
   using the US-ASCII character set.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="TYPEt"><span class="keyword">type</span> <code class="type"></code>t</span> = <code class="type">string</code> </pre>
<div class="info ">
<div class="info-desc">
<p>An alias for the type of strings.</p>
</div>
</div>


<pre><span id="VALcompare"><span class="keyword">val</span> compare</span> : <code class="type"><a href="String.html#TYPEt">t</a> -> <a href="String.html#TYPEt">t</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>The comparison function for strings, with the same specification as
    <a href="Stdlib.html#VALcompare"><code class="code">compare</code></a>.  Along with the type <code class="code">t</code>, this function <code class="code">compare</code>
    allows the module <code class="code"><span class="constructor">String</span></code> to be passed as argument to the functors
    <a href="Set.Make.html"><code class="code"><span class="constructor">Set</span>.<span class="constructor">Make</span></code></a> and <a href="Map.Make.html"><code class="code"><span class="constructor">Map</span>.<span class="constructor">Make</span></code></a>.</p>
</div>
</div>

<pre><span id="VALequal"><span class="keyword">val</span> equal</span> : <code class="type"><a href="String.html#TYPEt">t</a> -> <a href="String.html#TYPEt">t</a> -> bool</code></pre><div class="info ">
<div class="info-desc">
<p>The equal function for strings.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="VALsplit_on_char"><span class="keyword">val</span> split_on_char</span> : <code class="type">char -> string -> string list</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">String</span>.split_on_char&nbsp;sep&nbsp;s</code> returns the list of all (possibly empty)
    substrings of <code class="code">s</code> that are delimited by the <code class="code">sep</code> character.</p>

<p>The function's output is specified by the following invariants:</p>

<ul>
<li>The list is not empty.</li>
<li>Concatenating its elements using <code class="code">sep</code> as a separator returns a
      string equal to the input (<code class="code"><span class="constructor">String</span>.concat&nbsp;(<span class="constructor">String</span>.make&nbsp;1&nbsp;sep)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(<span class="constructor">String</span>.split_on_char&nbsp;sep&nbsp;s)&nbsp;=&nbsp;s</code>).</li>
<li>No string in the result contains the <code class="code">sep</code> character.</li>
</ul>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.04.0</li>
</ul>
</div>
<h2 id="1_Iterators">Iterators</h2>
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type"><a href="String.html#TYPEt">t</a> -> char <a href="Seq.html#TYPEt">Seq.t</a></code></pre><div class="info ">
<div class="info-desc">
<p>Iterate on the string, in increasing index order. Modifications of the
    string during iteration will be reflected in the iterator.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.07</li>
</ul>
</div>

<pre><span id="VALto_seqi"><span class="keyword">val</span> to_seqi</span> : <code class="type"><a href="String.html#TYPEt">t</a> -> (int * char) <a href="Seq.html#TYPEt">Seq.t</a></code></pre><div class="info ">
<div class="info-desc">
<p>Iterate on the string, in increasing order, yielding indices along chars</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.07</li>
</ul>
</div>

<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">char <a href="Seq.html#TYPEt">Seq.t</a> -> <a href="String.html#TYPEt">t</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create a string from the generator</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.07</li>
</ul>
</div>
</body></html>