Stdlib.In_channel
Input channels.
This module provides functions for working with input channels.
See the example section below.
type t = in_channel;
The type of input channel.
type open_flag = open_flag =
| Open_rdonly
open for reading.
*/| Open_wronly
open for writing.
*/| Open_append
open for appending: always write at end of file.
*/| Open_creat
create the file if it does not exist.
*/| Open_trunc
empty the file if it already exists.
*/| Open_excl
fail if Open_creat and the file already exists.
*/| Open_binary
open in binary mode (no conversion).
*/| Open_text
open in text mode (may perform conversions).
*/| Open_nonblock
open in non-blocking mode.
*/;
Opening modes for open_gen
.
let stdin: t;
The standard input for the process.
let open_bin: string => t;
Open the named file for reading, and return a new input channel on that file, positioned at the beginning of the file.
let open_text: string => t;
let with_open_bin: string => (t => 'a) => 'a;
with_open_bin fn f
opens a channel ic
on file fn
and returns f
ic
. After f
returns, either with a value or by raising an exception, ic
is guaranteed to be closed.
let with_open_text: string => (t => 'a) => 'a;
Like with_open_bin
, but the channel is opened in text mode (see open_text
).
Like with_open_bin
, but can specify the opening mode and file permission, in case the file must be created (see open_gen
).
let close: t => unit;
Close the given channel. Input functions raise a Sys_error
exception when they are applied to a closed input channel, except close
, which does nothing when applied to an already closed channel.
let input_char: t => option(char);
Read one character from the given input channel. Returns None
if there are no more characters to read.
let input_byte: t => option(int);
Same as input_char
, but return the 8-bit integer representing the character. Returns None
if the end of file was reached.
let input_line: t => option(string);
input_line ic
reads characters from ic
until a newline or the end of file is reached. Returns the string of all characters read, without the newline (if any). Returns None
if the end of the file has been reached. In particular, this will be the case if the last line of input is empty.
A newline is the character \n
unless the file is open in text mode and Sys.win32
is true
in which case it is the sequence of characters \r\n
.
let really_input_string: t => int => option(string);
really_input_string ic len
reads len
characters from channel ic
and returns them in a new string. Returns None
if the end of file is reached before len
characters have been read.
If the same channel is read concurrently by multiple threads, the returned string is not guaranteed to contain contiguous characters from the input.
let input_all: t => string;
input_all ic
reads all remaining data from ic
.
If the same channel is read concurrently by multiple threads, the returned string is not guaranteed to contain contiguous characters from the input.
let input_lines: t => list(string);
input_lines ic
reads lines using input_line
until the end of file is reached. It returns the list of all lines read, in the order they were read. The newline characters that terminate lines are not included in the returned strings. Empty lines produce empty strings.
let input: t => bytes => int => int => int;
input ic buf pos len
reads up to len
characters from the given channel ic
, storing them in byte sequence buf
, starting at character number pos
. It returns the actual number of characters read, between 0 and len
(inclusive). A return value of 0 means that the end of file was reached.
Use really_input
to read exactly len
characters.
let really_input: t => bytes => int => int => option(unit);
really_input ic buf pos len
reads len
characters from channel ic
, storing them in byte sequence buf
, starting at character number pos
.
Returns None
if the end of file is reached before len
characters have been read.
If the same channel is read concurrently by multiple threads, the bytes read by really_input
are not guaranteed to be contiguous.
let fold_lines: ('acc => string => 'acc) => 'acc => t => 'acc;
fold_lines f init ic
reads lines from ic
using input_line
until the end of file is reached, and successively passes each line to function f
in the style of a fold. More precisely, if lines l1, ..., lN
are read, fold_lines f init ic
computes f (... (f (f init l1) l2) ...) lN
. If f
has no side effects, this is equivalent to List.fold_left f init (In_channel.input_lines ic)
, but is more efficient since it does not construct the list of all lines read.
let seek: t => int64 => unit;
seek chan pos
sets the current reading position to pos
for channel chan
. This works only for regular files. On files of other kinds, the behavior is unspecified.
let pos: t => int64;
Return the current reading position for the given channel. For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos
, then going back to this position using seek
will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
let length: t => int64;
Return the size (number of characters) of the regular file on which the given channel is opened. If the channel is opened on a file that is not a regular file, the result is meaningless. The returned size does not take into account the end-of-line translations that can be performed when reading from a channel opened in text mode.
let set_binary_mode: t => bool => unit;
set_binary_mode ic true
sets the channel ic
to binary mode: no translations take place during input.
set_binary_mode ic false
sets the channel ic
to text mode: depending on the operating system, some translations may take place during input. For instance, under Windows, end-of-lines will be translated from \r\n
to \n
.
This function has no effect under operating systems that do not distinguish between text mode and binary mode.
let isatty: t => bool;
isatty ic
is true
if ic
refers to a terminal or console window, false
otherwise.
Reading the contents of a file:
let read_file file = In_channel.with_open_bin file In_channel.input_all
Reading a line from stdin:
let user_input () = In_channel.input_line In_channel.stdin