Sophie: ocaml-extlib-1.7.5-3.mga7 armv7hl

ocaml-extlib-1.7.5-3.mga7.armv7hl.rpm

<!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="Global.html">
<link rel="next" href="OptParse.html">
<link rel="Up" href="index.html">
<link title="Index of types" rel=Appendix href="index_types.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 class methods" rel=Appendix href="index_methods.html">
<link title="Index of classes" rel=Appendix href="index_classes.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="Base64" rel="Chapter" href="Base64.html">
<link title="BitSet" rel="Chapter" href="BitSet.html">
<link title="Dllist" rel="Chapter" href="Dllist.html">
<link title="DynArray" rel="Chapter" href="DynArray.html">
<link title="Enum" rel="Chapter" href="Enum.html">
<link title="ExtArray" rel="Chapter" href="ExtArray.html">
<link title="ExtBuffer" rel="Chapter" href="ExtBuffer.html">
<link title="ExtBytes" rel="Chapter" href="ExtBytes.html">
<link title="ExtHashtbl" rel="Chapter" href="ExtHashtbl.html">
<link title="ExtLib" rel="Chapter" href="ExtLib.html">
<link title="ExtList" rel="Chapter" href="ExtList.html">
<link title="ExtString" rel="Chapter" href="ExtString.html">
<link title="Global" rel="Chapter" href="Global.html">
<link title="IO" rel="Chapter" href="IO.html">
<link title="OptParse" rel="Chapter" href="OptParse.html">
<link title="Option" rel="Chapter" href="Option.html">
<link title="PMap" rel="Chapter" href="PMap.html">
<link title="RefList" rel="Chapter" href="RefList.html">
<link title="Std" rel="Chapter" href="Std.html">
<link title="UChar" rel="Chapter" href="UChar.html">
<link title="UTF8" rel="Chapter" href="UTF8.html">
<link title="Unzip" rel="Chapter" href="Unzip.html"><link title="Standard API" rel="Section" href="#6_StandardAPI">
<link title="Creation of IO Inputs/Outputs" rel="Section" href="#6_CreationofIOInputsOutputs">
<link title="Utilities" rel="Section" href="#6_Utilities">
<link title="Binary files API" rel="Section" href="#6_BinaryfilesAPI">
<link title="Bits API" rel="Section" href="#6_BitsAPI">
<link title="Generic IO Object Wrappers" rel="Section" href="#6_GenericIOObjectWrappers">
<title>IO</title>
</head>
<body>
<div class="navbar"><a class="pre" href="Global.html" title="Global">Previous</a>
&nbsp;<a class="up" href="index.html" title="Index">Up</a>
&nbsp;<a class="post" href="OptParse.html" title="OptParse">Next</a>
</div>
<h1>Module <a href="type_IO.html">IO</a></h1>

<pre><span id="MODULEIO"><span class="keyword">module</span> IO</span>: <code class="code">sig</code> <a href="IO.html">..</a> <code class="code">end</code></pre><div class="info module top">
<div class="info-desc">
<p>High-order abstract I/O.</p>

<p>IO module simply deals with abstract inputs/outputs. It provides a
  set of methods for working with these IO as well as several
  constructors that enable to write to an underlying channel, buffer,
  or enum.</p>
</div>
</div>
<hr width="100%">

<pre><span id="TYPEinput"><span class="keyword">type</span> <code class="type"></code>input</span> </pre>
<div class="info ">
<div class="info-desc">
<p>The abstract input type.</p>
</div>
</div>


<pre><span id="TYPEoutput"><span class="keyword">type</span> <code class="type">'a</code> output</span> </pre>
<div class="info ">
<div class="info-desc">
<p>The abstract output type, <code class="code">'a</code> is the accumulator data, it is returned
  when the <code class="code">close_out</code> function is called.</p>
</div>
</div>


<pre><span id="EXCEPTIONNo_more_input"><span class="keyword">exception</span> No_more_input</span></pre>
<div class="info ">
<div class="info-desc">
<p>This exception is raised when reading on an input with the <code class="code">read</code> or
  <code class="code">nread</code> functions while there is no available token to read.</p>
</div>
</div>

<pre><span id="EXCEPTIONInput_closed"><span class="keyword">exception</span> Input_closed</span></pre>
<div class="info ">
<div class="info-desc">
<p>This exception is raised when reading on a closed input.</p>
</div>
</div>

<pre><span id="EXCEPTIONOutput_closed"><span class="keyword">exception</span> Output_closed</span></pre>
<div class="info ">
<div class="info-desc">
<p>This exception is raised when reading on a closed output.</p>
</div>
</div>
<h7 id="6_StandardAPI">Standard API</h7>
<pre><span id="VALread"><span class="keyword">val</span> read</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> char</code></pre><div class="info ">
<div class="info-desc">
<p>Read a single char from an input or raise <code class="code">No_more_input</code> if
  no input available.</p>
</div>
</div>

<pre><span id="VALnread"><span class="keyword">val</span> nread</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int -> ExtBytes.Bytes.t</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">nread i n</code> reads a byte sequence of size up to <code class="code">n</code> from an input.
  The function will raise <code class="code">No_more_input</code> if no input is available.
  It will raise <code class="code">Invalid_argument</code> if <code class="code">n</code> &lt; 0.</p>
</div>
</div>

<pre><span id="VALreally_nread"><span class="keyword">val</span> really_nread</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int -> ExtBytes.Bytes.t</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">really_nread i n</code> reads a byte sequence of exactly <code class="code">n</code> characters
  from the input. Raises <code class="code">No_more_input</code> if at least <code class="code">n</code> characters are
  not available. Raises <code class="code">Invalid_argument</code> if <code class="code">n</code> &lt; 0.</p>
</div>
</div>

<pre><span id="VALnread_string"><span class="keyword">val</span> nread_string</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int -> string</code></pre><div class="info ">
<div class="info-desc">
<p>as <code class="code">nread</code>, but reads a string.</p>
</div>
</div>

<pre><span id="VALreally_nread_string"><span class="keyword">val</span> really_nread_string</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int -> string</code></pre><div class="info ">
<div class="info-desc">
<p>as <code class="code">really_nread</code>, but reads a string.</p>
</div>
</div>

<pre><span id="VALinput"><span class="keyword">val</span> input</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> ExtBytes.Bytes.t -> int -> int -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">input i b p l</code> reads up to <code class="code">l</code> characters from the given input, storing
  them in buffer <code class="code">b</code>, starting at character number <code class="code">p</code>. It returns the actual
  number of characters read or raise <code class="code">No_more_input</code> if no character can be
  read. It will raise <code class="code">Invalid_argument</code> if <code class="code">p</code> and <code class="code">l</code> do not designate a
  valid subsequence of <code class="code">b</code>.</p>
</div>
</div>

<pre><span id="VALreally_input"><span class="keyword">val</span> really_input</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> ExtBytes.Bytes.t -> int -> int -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">really_input i b p l</code> reads exactly <code class="code">l</code> characters from the given input,
  storing them in the buffer <code class="code">b</code>, starting at position <code class="code">p</code>. For consistency with
  <a href="IO.html#VALinput"><code class="code">IO.input</code></a> it returns <code class="code">l</code>. Raises <code class="code">No_more_input</code> if at <code class="code">l</code> characters are
  not available. Raises <code class="code">Invalid_argument</code> if <code class="code">p</code> and <code class="code">l</code> do not designate a
  valid subsequence of <code class="code">b</code>.</p>
</div>
</div>

<pre><span id="VALclose_in"><span class="keyword">val</span> close_in</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Close the input. It can no longer be read from.</p>
</div>
</div>

<pre><span id="VALwrite"><span class="keyword">val</span> write</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> char -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write a single char to an output.</p>
</div>
</div>

<pre><span id="VALnwrite"><span class="keyword">val</span> nwrite</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> ExtBytes.Bytes.t -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write a byte sequence to an output.</p>
</div>
</div>

<pre><span id="VALnwrite_string"><span class="keyword">val</span> nwrite_string</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> string -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write a string to an output.</p>
</div>
</div>

<pre><span id="VALoutput"><span class="keyword">val</span> output</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> ExtBytes.Bytes.t -> int -> int -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">output o b p l</code> writes up to <code class="code">l</code> characters from byte sequence <code class="code">b</code>, starting at
  offset <code class="code">p</code>. It returns the number of characters written. It will raise
  <code class="code">Invalid_argument</code> if <code class="code">p</code> and <code class="code">l</code> do not designate a valid subsequence of <code class="code">b</code>.</p>
</div>
</div>

<pre><span id="VALreally_output"><span class="keyword">val</span> really_output</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> ExtBytes.Bytes.t -> int -> int -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">really_output o b p l</code> writes exactly <code class="code">l</code> characters from byte sequence <code class="code">b</code> onto
  the the output, starting with the character at offset <code class="code">p</code>. For consistency with
  <a href="IO.html#VALoutput"><code class="code">IO.output</code></a> it returns <code class="code">l</code>. Raises <code class="code">Invalid_argument</code> if <code class="code">p</code> and <code class="code">l</code> do not
  designate a valid subsequence of <code class="code">b</code>.</p>
</div>
</div>

<pre><span id="VALflush"><span class="keyword">val</span> flush</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Flush an output.</p>
</div>
</div>

<pre><span id="VALclose_out"><span class="keyword">val</span> close_out</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> 'a</code></pre><div class="info ">
<div class="info-desc">
<p>Close the output and return its accumulator data.
  It can no longer be written.</p>
</div>
</div>
<h7 id="6_CreationofIOInputsOutputs">Creation of IO Inputs/Outputs</h7>
<pre><span id="VALinput_string"><span class="keyword">val</span> input_string</span> : <code class="type">string -> <a href="IO.html#TYPEinput">input</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create an input that will read from a string.</p>
</div>
</div>

<pre><span id="VALinput_bytes"><span class="keyword">val</span> input_bytes</span> : <code class="type">ExtBytes.Bytes.t -> <a href="IO.html#TYPEinput">input</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create an input that will read from a byte sequence.</p>
</div>
</div>

<pre><span id="VALoutput_string"><span class="keyword">val</span> output_string</span> : <code class="type">unit -> string <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create an output that will write into a string in an efficient way.
  When closed, the output returns all the data written into it.</p>
</div>
</div>

<pre><span id="VALoutput_bytes"><span class="keyword">val</span> output_bytes</span> : <code class="type">unit -> ExtBytes.Bytes.t <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create an output that will write into a byte sequence in an efficient way.
  When closed, the output returns all the data written into it.</p>
</div>
</div>

<pre><span id="VALoutput_strings"><span class="keyword">val</span> output_strings</span> : <code class="type">unit -> string list <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create an output that will write into a string in an efficient way.
  When closed, the output returns all the data written into it.
  Several strings are used in case the output size excess max_string_length</p>
</div>
</div>

<pre><span id="VALinput_channel"><span class="keyword">val</span> input_channel</span> : <code class="type">Stdlib.in_channel -> <a href="IO.html#TYPEinput">input</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create an input that will read from a channel.</p>
</div>
</div>

<pre><span id="VALoutput_channel"><span class="keyword">val</span> output_channel</span> : <code class="type">Stdlib.out_channel -> unit <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create an output that will write into a channel.</p>
</div>
</div>

<pre><span id="VALinput_enum"><span class="keyword">val</span> input_enum</span> : <code class="type">char <a href="Enum.html#TYPEt">Enum.t</a> -> <a href="IO.html#TYPEinput">input</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create an input that will read from an <code class="code">enum</code>.</p>
</div>
</div>

<pre><span id="VALoutput_enum"><span class="keyword">val</span> output_enum</span> : <code class="type">unit -> char <a href="Enum.html#TYPEt">Enum.t</a> <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create an output that will write into an <code class="code">enum</code>. The
  final enum is returned when the output is closed.</p>
</div>
</div>

<pre><span id="VALcreate_in"><span class="keyword">val</span> create_in</span> : <code class="type">read:(unit -> char) -><br>       input:(ExtBytes.Bytes.t -> int -> int -> int) -><br>       close:(unit -> unit) -> <a href="IO.html#TYPEinput">input</a></code></pre><div class="info ">
<div class="info-desc">
<p>Fully create an input by giving all the needed functions.</p>
</div>
</div>

<pre><span id="VALcreate_out"><span class="keyword">val</span> create_out</span> : <code class="type">write:(char -> unit) -><br>       output:(ExtBytes.Bytes.t -> int -> int -> int) -><br>       flush:(unit -> unit) -> close:(unit -> 'a) -> 'a <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info ">
<div class="info-desc">
<p>Fully create an output by giving all the needed functions.</p>
</div>
</div>
<h7 id="6_Utilities">Utilities</h7>
<pre><span id="VALscanf"><span class="keyword">val</span> scanf</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> ('a, 'b, 'c, 'd) Stdlib.Scanf.scanner</code></pre><div class="info ">
<div class="info-desc">
<p>The scanf function works for any input.</p>
</div>
</div>

<pre><span id="VALprintf"><span class="keyword">val</span> printf</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> ('b, unit, string, unit) Stdlib.format4 -> 'b</code></pre><div class="info ">
<div class="info-desc">
<p>The printf function works for any output.</p>
</div>
</div>

<pre><span id="VALread_all"><span class="keyword">val</span> read_all</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> string</code></pre><div class="info ">
<div class="info-desc">
<p>read all the contents of the input until <code class="code">No_more_input</code> is raised.</p>
</div>
</div>

<pre><span id="VALpipe"><span class="keyword">val</span> pipe</span> : <code class="type">unit -> <a href="IO.html#TYPEinput">input</a> * unit <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info ">
<div class="info-desc">
<p>Create a pipe between an input and an ouput. Data written from
  the output can be read from the input.</p>
</div>
</div>

<pre><span id="VALpos_in"><span class="keyword">val</span> pos_in</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> <a href="IO.html#TYPEinput">input</a> * (unit -> int)</code></pre><div class="info ">
<div class="info-desc">
<p>Create an input that provide a count function of the number of Bytes.t
  read from it.</p>
</div>
</div>

<pre><span id="VALpos_out"><span class="keyword">val</span> pos_out</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> 'a <a href="IO.html#TYPEoutput">output</a> * (unit -> int)</code></pre><div class="info ">
<div class="info-desc">
<p>Create an output that provide a count function of the number of Bytes.t
  written through it.</p>
</div>
</div>

<pre><span id="VALcast_output"><span class="keyword">val</span> cast_output</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> unit <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info ">
<div class="info-desc">
<p>You can safely transform any output to an unit output in a safe way
  by using this function.</p>
</div>
</div>
<h7 id="6_BinaryfilesAPI">Binary files API</h7>
<p>Here is some API useful for working with binary files, in particular
  binary files generated by C applications. By default, encoding of
  multibyte integers is low-endian. The BigEndian module provide multibyte
  operations with other encoding.</p>

<pre><span id="EXCEPTIONOverflow"><span class="keyword">exception</span> Overflow</span> <span class="keyword">of</span> <code class="type">string</code></pre>
<div class="info ">
<div class="info-desc">
<p>Exception raised when a read or write operation cannot be completed.</p>
</div>
</div>

<pre><span id="VALread_byte"><span class="keyword">val</span> read_byte</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Read an unsigned 8-bit integer.</p>
</div>
</div>

<pre><span id="VALread_signed_byte"><span class="keyword">val</span> read_signed_byte</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Read an signed 8-bit integer.</p>
</div>
</div>

<pre><span id="VALread_ui16"><span class="keyword">val</span> read_ui16</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Read an unsigned 16-bit word.</p>
</div>
</div>

<pre><span id="VALread_i16"><span class="keyword">val</span> read_i16</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Read a signed 16-bit word.</p>
</div>
</div>

<pre><span id="VALread_i31"><span class="keyword">val</span> read_i31</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Read a signed 32-bit integer. Raise <code class="code">Overflow</code> if the
  read integer cannot be represented as an OCaml 31-bit integer.</p>
</div>
</div>

<pre><span id="VALread_i32"><span class="keyword">val</span> read_i32</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Deprecated, same as read_i31</p>
</div>
</div>

<pre><span id="VALread_i32_as_int"><span class="keyword">val</span> read_i32_as_int</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Read a signed 32-bit integer, represented as OCaml integer, wrapping around 31-bit int on 32-bit architecture</p>
</div>
</div>

<pre><span id="VALread_real_i32"><span class="keyword">val</span> read_real_i32</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int32</code></pre><div class="info ">
<div class="info-desc">
<p>Read a signed 32-bit integer as an OCaml int32.</p>
</div>
</div>

<pre><span id="VALread_i64"><span class="keyword">val</span> read_i64</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int64</code></pre><div class="info ">
<div class="info-desc">
<p>Read a signed 64-bit integer as an OCaml int64.</p>
</div>
</div>

<pre><span id="VALread_float32"><span class="keyword">val</span> read_float32</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> float</code></pre><div class="info ">
<div class="info-desc">
<p>Read an IEEE single precision floating point value (32 bits).</p>
</div>
</div>

<pre><span id="VALread_double"><span class="keyword">val</span> read_double</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> float</code></pre><div class="info ">
<div class="info-desc">
<p>Read an IEEE double precision floating point value (64 bits).</p>
</div>
</div>

<pre><span id="VALread_string"><span class="keyword">val</span> read_string</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Read a null-terminated string.</p>
</div>
</div>

<pre><span id="VALread_bytes"><span class="keyword">val</span> read_bytes</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> ExtBytes.Bytes.t</code></pre><div class="info ">
<div class="info-desc">
<p>Read a null-terminated byte sequence.</p>
</div>
</div>

<pre><span id="VALread_line"><span class="keyword">val</span> read_line</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> string</code></pre><div class="info ">
<div class="info-desc">
<p>Read a LF or CRLF terminated string.</p>
</div>
</div>

<pre><span id="VALwrite_byte"><span class="keyword">val</span> write_byte</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write an unsigned 8-bit byte.</p>
</div>
</div>

<pre><span id="VALwrite_ui16"><span class="keyword">val</span> write_ui16</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write an unsigned 16-bit word.</p>
</div>
</div>

<pre><span id="VALwrite_i16"><span class="keyword">val</span> write_i16</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write a signed 16-bit word.</p>
</div>
</div>

<pre><span id="VALwrite_i31"><span class="keyword">val</span> write_i31</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write a signed 31-bit integer as 4 bytes.</p>
</div>
</div>

<pre><span id="VALwrite_i32"><span class="keyword">val</span> write_i32</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write a signed 32-bit integer.</p>
</div>
</div>

<pre><span id="VALwrite_real_i32"><span class="keyword">val</span> write_real_i32</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int32 -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write an OCaml int32.</p>
</div>
</div>

<pre><span id="VALwrite_i64"><span class="keyword">val</span> write_i64</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int64 -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write an OCaml int64.</p>
</div>
</div>

<pre><span id="VALwrite_float32"><span class="keyword">val</span> write_float32</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> float -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write an IEEE single precision floating point value (32 bits).</p>
</div>
</div>

<pre><span id="VALwrite_double"><span class="keyword">val</span> write_double</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> float -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write an IEEE double precision floating point value (64 bits).</p>
</div>
</div>

<pre><span id="VALwrite_string"><span class="keyword">val</span> write_string</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> string -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write a string and append an null character.</p>
</div>
</div>

<pre><span id="VALwrite_bytes"><span class="keyword">val</span> write_bytes</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> ExtBytes.Bytes.t -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write a byte sequence and append an null character.</p>
</div>
</div>

<pre><span id="VALwrite_line"><span class="keyword">val</span> write_line</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> string -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write a line and append a LF (it might be converted
  to CRLF on some systems depending on the underlying IO).</p>
</div>
</div>

<pre><span id="MODULEBigEndian"><span class="keyword">module</span> <a href="IO.BigEndian.html">BigEndian</a></span>: <code class="code">sig</code> <a href="IO.BigEndian.html">..</a> <code class="code">end</code></pre><div class="info">
<p>Same as operations above, but use big-endian encoding</p>

</div>
<h7 id="6_BitsAPI">Bits API</h7>
<p>This enable you to read and write from an IO bit-by-bit or several bits
  at the same time.</p>

<pre><span id="TYPEin_bits"><span class="keyword">type</span> <code class="type"></code>in_bits</span> </pre>


<pre><span id="TYPEout_bits"><span class="keyword">type</span> <code class="type"></code>out_bits</span> </pre>


<pre><span id="EXCEPTIONBits_error"><span class="keyword">exception</span> Bits_error</span></pre>

<pre><span id="VALinput_bits"><span class="keyword">val</span> input_bits</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> <a href="IO.html#TYPEin_bits">in_bits</a></code></pre><div class="info ">
<div class="info-desc">
<p>Read bits from an input</p>
</div>
</div>

<pre><span id="VALoutput_bits"><span class="keyword">val</span> output_bits</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> <a href="IO.html#TYPEout_bits">out_bits</a></code></pre><div class="info ">
<div class="info-desc">
<p>Write bits to an output</p>
</div>
</div>

<pre><span id="VALread_bits"><span class="keyword">val</span> read_bits</span> : <code class="type"><a href="IO.html#TYPEin_bits">in_bits</a> -> int -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Read up to 31 bits, raise Bits_error if n &lt; 0 or n &gt; 31</p>
</div>
</div>

<pre><span id="VALwrite_bits"><span class="keyword">val</span> write_bits</span> : <code class="type"><a href="IO.html#TYPEout_bits">out_bits</a> -> nbits:int -> int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Write up to 31 bits represented as a value, raise Bits_error if nbits &lt; 0
 or nbits &gt; 31 or the value representation excess nbits.</p>
</div>
</div>

<pre><span id="VALflush_bits"><span class="keyword">val</span> flush_bits</span> : <code class="type"><a href="IO.html#TYPEout_bits">out_bits</a> -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Flush remaining unwritten bits, adding up to 7 bits which values 0.</p>
</div>
</div>

<pre><span id="VALdrop_bits"><span class="keyword">val</span> drop_bits</span> : <code class="type"><a href="IO.html#TYPEin_bits">in_bits</a> -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Drop up to 7 buffered bits and restart to next input character.</p>
</div>
</div>
<h7 id="6_GenericIOObjectWrappers">Generic IO Object Wrappers</h7>
<p>Theses OO Wrappers have been written to provide easy support of ExtLib
  IO by external librairies. If you want your library to support ExtLib
  IO without actually requiring ExtLib to compile, you can should implement
  the classes <code class="code">in_channel</code>, <code class="code">out_channel</code>, <code class="code">poly_in_channel</code> and/or
  <code class="code">poly_out_channel</code> which are the common IO specifications established
  for ExtLib, OCamlNet and Camomile.</p>

<p>(see http://www.ocaml-programming.de/tmp/IO-Classes.html for more details).</p>

<pre><span id="TYPEin_channel"><span class="keyword">class</span> <a href="IO.in_channel-c.html">in_channel</a></span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> </code><code class="code">object</code> <a href="IO.in_channel-c.html">..</a> <code class="code">end</code></pre>
<pre><span id="TYPEout_channel"><span class="keyword">class</span> <a href="IO.out_channel-c.html">out_channel</a></span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> </code><code class="code">object</code> <a href="IO.out_channel-c.html">..</a> <code class="code">end</code></pre>
<pre><span id="TYPEin_chars"><span class="keyword">class</span> <a href="IO.in_chars-c.html">in_chars</a></span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> </code><code class="code">object</code> <a href="IO.in_chars-c.html">..</a> <code class="code">end</code></pre>
<pre><span id="TYPEout_chars"><span class="keyword">class</span> <a href="IO.out_chars-c.html">out_chars</a></span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> </code><code class="code">object</code> <a href="IO.out_chars-c.html">..</a> <code class="code">end</code></pre>
<pre><span id="VALfrom_in_channel"><span class="keyword">val</span> from_in_channel</span> : <code class="type">#<a href="IO.in_channel-c.html">in_channel</a> -> <a href="IO.html#TYPEinput">input</a></code></pre>
<pre><span id="VALfrom_out_channel"><span class="keyword">val</span> from_out_channel</span> : <code class="type">#<a href="IO.out_channel-c.html">out_channel</a> -> unit <a href="IO.html#TYPEoutput">output</a></code></pre>
<pre><span id="VALfrom_in_chars"><span class="keyword">val</span> from_in_chars</span> : <code class="type">#<a href="IO.in_chars-c.html">in_chars</a> -> <a href="IO.html#TYPEinput">input</a></code></pre>
<pre><span id="VALfrom_out_chars"><span class="keyword">val</span> from_out_chars</span> : <code class="type">#<a href="IO.out_chars-c.html">out_chars</a> -> unit <a href="IO.html#TYPEoutput">output</a></code></pre></body></html>