Модуль Stdlib

module Stdlib: sig .. end

Стандартная библиотека OCaml.

Этот модуль автоматически открывается в начале каждой компиляции. Все компоненты этого модуля могут поэтому быть упомянуты по их короткому имени, без префикса Stdlib.

В частности, он предоставляет базовые операции над встроенными типами (числа, булевы значения, последовательности байтов, строки, исключения, ссылки, списки, массивы, каналы ввода-вывода, ...) и модули стандартной библиотеки.

Исключения

val raise : exn -> 'a

Вызывает заданное значение исключения

val raise_notrace : exn -> 'a

Более быстрая версия raise, которая не записывает обратный след.

С момента 4.02.0

val invalid_arg : string -> 'a

Вызывает исключение Invalid_argument с заданной строкой.

val failwith : string -> 'a

Вызывает исключение Failure с заданной строкой.

exception Exit

Исключение Exit не вызывается никакой функцией библиотеки. Оно предоставлено для использования в ваших программах.

exception Match_failure of (string * int * int)

Исключение, возникающее, когда ни один из вариантов сопоставления с образцом не применим. Аргументы — местоположение ключевого слова match в исходном коде (имя файла, номер строки, номер столбца).

exception Assert_failure of (string * int * int)

Исключение, возникающее при сбое утверждения. Аргументы — местоположение ключевого слова assert в исходном коде (имя файла, номер строки, номер столбца).

exception Invalid_argument of string

Исключение, вызываемое функциями библиотеки для сигнализации о том, что заданные аргументы не имеют смысла. Строка предоставляет некоторую информацию программисту. Как общее правило, это исключение не должно перехватываться; оно обозначает ошибку программирования, и код должен быть изменён, чтобы не вызывать его.

exception Failure of string

Исключение, вызываемое функциями библиотеки для сигнализации о том, что они не определены для заданных аргументов. Строка предназначена для предоставления некоторой информации программисту; вы не должны выполнять сопоставление с образцом со строковой литеральной частью, поскольку она может измениться в будущих версиях (используйте Failure _ вместо этого).

exception Not_found

Исключение, вызываемое функциями поиска, когда искомый объект не был найден.

exception Out_of_memory

Исключение, генерируемое сборщиком мусора, когда памяти недостаточно для завершения вычисления. (Ненадёжно для выделения памяти на меньшей куче.)

exception Stack_overflow

Исключение, генерируемое интерпретатором байткода, когда стек вычислений достигает максимального размера. Это часто указывает на бесконечную или чрезмерно глубокую рекурсию в программе пользователя.

До версии 4.10 оно не было полностью реализовано компилятором нативного кода.

exception Sys_error of string

Исключение, генерируемое функциями ввода/вывода для сообщения об ошибке операционной системы. Строка предназначена для предоставления некоторой информации программисту; не следует использовать сопоставление с образцом по строковому литералу, поскольку он может измениться в будущих версиях (используйте Sys_error вместо этого).

exception End_of_file

Исключение, генерируемое функциями ввода, чтобы сигнализировать о достижении конца файла.

exception Division_by_zero

Исключение, генерируемое операциями целочисленного деления и остатка, когда их второй аргумент равен нулю.

exception Sys_blocked_io

Особый случай Sys_error, генерируемый, когда нет возможности ввода/вывода в канале ввода/вывода без блокировки.

exception Undefined_recursive_module of (string * int * int)

Исключение, генерируемое при оценке определения модуля с ошибочной рекурсией. Аргументы — местоположение определения в исходном коде (имя файла, номер строки, номер столбца).

Сравнения

val (=) : 'a -> 'a -> bool

e1 = e2 проверяет структурное равенство e1 и e2. Изменяемые структуры (например, ссылки и массивы) равны тогда и только тогда, когда их текущее содержимое структурно равно, даже если два изменяемых объекта не являются одним и тем же физическим объектом. Равенство между функциональными значениями вызывает Invalid_argument. Равенство между циклическими структурами данных может не завершиться. Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (<>) : 'a -> 'a -> bool

Отрицание (=). Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (<) : 'a -> 'a -> bool

См. (>=). Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (>) : 'a -> 'a -> bool

См. (>=). Оператор левоассоциативного типа, см. Ocaml_operators для получения дополнительной информации.

val (<=) : 'a -> 'a -> bool

См. (>=). Оператор левоассоциативного типа, см. Ocaml_operators для получения дополнительной информации.

val (>=) : 'a -> 'a -> bool

Функции структурного упорядочения. Эти функции совпадают с обычными порядками над целыми числами, символами, строками, последовательностями байтов и числами с плавающей запятой и расширяют их до полного порядка по всем типам. Порядок совместим с ( = ). Как и в случае с ( = ), изменяемые структуры сравниваются по содержанию. Сравнение между функциональными значениями вызывает Invalid_argument. Сравнение между циклическими структурами может не завершиться. Оператор левоассоциативного типа, см. Ocaml_operators для получения дополнительной информации.

val compare : 'a -> 'a -> int

compare x y возвращает 0 , если x равно y, отрицательное целое число, если x меньше y, и положительное целое число, если x больше y. Порядок, реализованный compare , совместим с предикатами сравнения =, < и > , определёнными выше, с одним отличием в обработке значения float nan. Иными словами, предикаты сравнения рассматривают nan как отличное от любого другого значения float, включая себя; в то время как compare рассматривает nan как равное самому себе и меньшее любого другого значения float. Эта обработка nan гарантирует, что compare определяет отношение полного порядка.

compare при применении к функциональным значениям может вызвать Invalid_argument. compare при применении к циклическим структурам может не завершиться.

Функция compare может быть использована в качестве функции сравнения, необходимой для модулей Set.Make и Map.Make, а также функций List.sort и Array.sort.

val min : 'a -> 'a -> 'a

Возвращает меньший из двух аргументов. Результат не определён, если один из аргументов содержит значение с плавающей запятой nan.

val max : 'a -> 'a -> 'a

Возвращает большее из двух аргументов. Результат не определён, если один из аргументов содержит значение с плавающей точкой nan.

val (==) : 'a -> 'a -> bool

e1 == e2 проверяет физическое равенство e1 и e2. Для изменяемых типов, таких как ссылки, массивы, последовательности байтов, записи с изменяемыми полями и объекты с изменяемыми переменными экземпляра, e1 == e2 истинно тогда и только тогда, когда физическое изменение e1 также влияет на e2. Для неизменяемых типов поведение ( == ) зависит от реализации; однако гарантируется, что e1 == e2 подразумевает compare e1 e2 = 0. Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (!=) : 'a -> 'a -> bool

Отрицание (==). Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

Логические операции

val not : bool -> bool

Логическое отрицание.

val (&&) : bool -> bool -> bool

Логическое 'и'. Вычисление происходит последовательно, слева направо: в e1 && e2, e1 вычисляется в первую очередь, и если он возвращает false, e2 вообще не вычисляется. Правоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (&) : bool -> bool -> bool

Устарело. (&&) следует использовать вместо этого. Правоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (||) : bool -> bool -> bool

Логическое 'или'. Вычисление происходит последовательно, слева направо: в e1 || e2, e1 вычисляется в первую очередь, и если он возвращает true, e2 вообще не вычисляется. Правоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (or) : bool -> bool -> bool

Устарело. (||) следует использовать вместо этого. Правоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

Отладка

val __LOC__ : string

Возвращает местоположение этого выражения в файле, который в данный момент парсит компилятор, в стандартном формате ошибок OCaml: «Файл %S, строка %d, символы %d-%d».

Since 4.02.0

val __FILE__ : string

Возвращает имя файла, который в данный момент парсит компилятор.

Since 4.02.0

val __LINE__ : int

Возвращает номер строки, в которой это выражение появляется в файле, который в данный момент парсит компилятор.

Since 4.02.0

val __MODULE__ : string

Возвращает имя модуля файла, который парсит компилятор.

Since 4.02.0

val __POS__ : string * int * int * int

Возвращает кортеж (file,lnum,cnum,enum), соответствующий месту, где это выражение появляется в файле, который в данный момент парсит компилятор. lnum — текущее имя файла, cnum — номер строки, enum — позиция символа в строке и file — последняя позиция символа в строке.

Since 4.02.0

val __FUNCTION__ : string

Возвращает имя текущей функции или метода, включая любые окружающие модули или классы.

Since 4.12.0

val __LOC_OF__ : 'a -> string * 'a

Возвращает пару (loc, expr), где loc — местоположение expr в файле, который в данный момент парсит компилятор, в стандартном формате ошибок OCaml: «Файл %S, строка %d, символы %d-%d».

Since 4.02.0

val __LINE_OF__ : 'a -> int * 'a

Возвращает пару (line, expr), где line — номер строки, в которой выражение expr появляется в файле, который в данный момент парсит компилятор.

Since 4.02.0

val __POS_OF__ : 'a -> (string * int * int * int) * 'a

__POS_OF__ expr возвращает пару (loc,expr), где loc — кортеж (file,lnum,cnum,enum), соответствующий местоположению выражения expr в файле, который в данный момент парсит компилятор. file — имя файла, lnum — номер строки, cnum — позиция символа в строке и enum — позиция последнего символа в строке.

Since 4.02.0

Операторы композиции

val (|>) : 'a -> ('a -> 'b) -> 'b

Оператор обратного применения: x |> f |> g точно эквивалентен g (f (x)). Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

Since 4.01

val (@@) : ('a -> 'b) -> 'a -> 'b

Оператор применения: g @@ f @@ x точно эквивалентен g (f (x)). Правоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

Since 4.01

Целочисленный арифметический

Целые числа имеют ширину Sys.int_size бит. Все операции выполняются по модулю 2^Sys.int_size. Переполнение не приводит к ошибкам.

val (~-) : int -> int

Унарное отрицание. Также можно записать - e вместо ~- e. Унарный оператор, см. Ocaml_operators для получения дополнительной информации.

val (~+) : int -> int

Унарное сложение. Также можно записать + e вместо ~+ e. Унарный оператор, см. Ocaml_operators для получения дополнительной информации.

Since 3.12.0

val succ : int -> int

succ x — x + 1.

val pred : int -> int

pred x — x - 1.

val (+) : int -> int -> int

Целочисленное сложение. Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (-) : int -> int -> int

Вычитание целых чисел. Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val ( * ) : int -> int -> int

Умножение целых чисел. Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (/) : int -> int -> int

Деление целых чисел. Целочисленное деление округляет действительное частное своих аргументов к нулю. Более точно, если x >= 0 и y > 0, x / y — это наибольшее целое число, меньшее или равное действительной частному от деления x на y. Кроме того, (- x) / y = x / (- y) = - (x / y). Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

Возбуждает Division_by_zero если второй аргумент равен 0.

val (mod) : int -> int -> int

Остаток от деления целых чисел. Если y не равно нулю, результат x mod y удовлетворяет следующим свойствам: x = (x / y) * y + x mod y и abs(x mod y) <= abs(y) - 1. Если y = 0, x mod y возбуждает Division_by_zero. Обратите внимание, что x mod y отрицательно только если x < 0. Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

Возбуждает Division_by_zero если y равно нулю.

val abs : int -> int

Возвращает абсолютное значение аргумента. Обратите внимание, что это может быть отрицательным, если аргумент min_int.

val max_int : int

Наибольшее представимое целое число.

val min_int : int

Наименьшее представимое целое число.

Битовые операции

val (land) : int -> int -> int

Битовое логическое И. Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (lor) : int -> int -> int

Битовое логическое ИЛИ. Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val (lxor) : int -> int -> int

Битовое логическое исключающее ИЛИ. Левоассоциативный оператор, см. Ocaml_operators для получения дополнительной информации.

val lnot : int -> int

Побитовое логическое отрицание.

val (lsl) : int -> int -> int

n lsl m сдвигает n влево на m бит. Результат не определен, если m < 0 или m > Sys.int_size. Оператор справа налево, см. Ocaml_operators для получения дополнительной информации.

val (lsr) : int -> int -> int

n lsr m сдвигает n вправо на m бит. Это логический сдвиг: нули вставляются независимо от знака n. Результат не определен, если m < 0 или m > Sys.int_size. Оператор справа налево, см. Ocaml_operators для получения дополнительной информации.

val (asr) : int -> int -> int

n asr m сдвигает n вправо на m бит. Это арифметический сдвиг: бит знака n дублируется. Результат не определен, если m < 0 или m > Sys.int_size. Оператор справа налево, см. Ocaml_operators для получения дополнительной информации.

Арифметика с плавающей точкой

Числа с плавающей точкой OCaml следуют стандарту IEEE 754, используя числа двойной точности (64 бита). Операции с плавающей точкой никогда не вызывают исключения при переполнении, недополнении, делении на ноль и т. д. Вместо этого возвращаются специальные числа IEEE, такие как infinity для 1.0 /. 0.0, neg_infinity для -1.0 /. 0.0, и nan ('не число') для 0.0 /. 0.0. Эти специальные числа затем распространяются через вычисления с плавающей точкой как ожидается: например, 1.0 /. infinity это 0.0, основные арифметические операции (+., -., *., /.) с nan в качестве аргумента возвращают nan, ...

val (~-.) : float -> float

Унарное отрицание. Вы также можете написать -. e вместо ~-. e. Унарный оператор, см. Ocaml_operators для получения дополнительной информации.

val (~+.) : float -> float

Унарное сложение. Вы также можете написать +. e вместо ~+. e. Унарный оператор, см. Ocaml_operators для получения дополнительной информации.

Since 3.12.0

val (+.) : float -> float -> float

Сложение с плавающей запятой. Оператор левоассоциативный, см. Ocaml_operators для получения дополнительной информации.

val (-.) : float -> float -> float

Вычитание с плавающей запятой. Оператор левоассоциативный, см. Ocaml_operators для получения дополнительной информации.

val ( *. ) : float -> float -> float

Умножение с плавающей запятой. Оператор левоассоциативный, см. Ocaml_operators для получения дополнительной информации.

val (/.) : float -> float -> float

Деление с плавающей запятой. Оператор левоассоциативный, см. Ocaml_operators для получения дополнительной информации.

val ( ** ) : float -> float -> float

Возведение в степень. Оператор правоассоциативный, см. Ocaml_operators для получения дополнительной информации.

val sqrt : float -> float

Квадратный корень.

val exp : float -> float

Экспонента.

val log : float -> float

Натуральный логарифм.

val log10 : float -> float

Логарифм по основанию 10.

val expm1 : float -> float

expm1 x вычисляет exp x -. 1.0, обеспечивая числовую точность даже если x близко к 0.0.

Since 3.12.0

val log1p : float -> float

log1p x вычисляет log(1.0 +. x) (натуральный логарифм), обеспечивая числовую точность даже если x близко к 0.0.

Since 3.12.0

val cos : float -> float

Косинус. Аргумент в радианах.

val sin : float -> float

Синус. Аргумент в радианах.

val tan : float -> float

Тангенс. Аргумент в радианах.

val acos : float -> float

Арккосинус. Аргумент должен находиться в диапазоне [-1.0, 1.0]. Результат в радианах и находится между 0.0 и pi.

val asin : float -> float

Арксинус. Аргумент должен находиться в диапазоне [-1.0, 1.0]. Результат в радианах и находится между -pi/2 и pi/2.

val atan : float -> float

Арктангенс. Результат в радианах и находится между -pi/2 и pi/2.

val atan2 : float -> float -> float

atan2 y x возвращает арктангенс y /. x. Знаки x и y используются для определения квадранта результата. Результат в радианах и находится между -pi и pi.

val hypot : float -> float -> float

hypot x y возвращает sqrt(x *. x + y *. y), то есть длину гипотенузы прямоугольного треугольника с катетами длины x и y, или, эквивалентно, расстояние точки (x,y) от начала координат. Если одно из x или y бесконечно, возвращает infinity даже если другое nan.

Since 4.00.0

val cosh : float -> float

Гиперболический косинус. Аргумент в радианах.

val sinh : float -> float

Гиперболический синус. Аргумент в радианах.

val tanh : float -> float

Гиперболический тангенс. Аргумент в радианах.

val acosh : float -> float

Гиперболический арккосинус. Аргумент должен находиться в диапазоне [1.0, inf]. Результат в радианах и находится между 0.0 и inf.

Since 4.13.0

val asinh : float -> float

Гиперболический арксинус. Аргумент и диапазон результатов охватывают всю действительную прямую. Результат в радианах.

Since 4.13.0

val atanh : float -> float

Гиперболический арктангенс. Аргумент должен находиться в диапазоне [-1.0, 1.0]. Результат в радианах и охватывает всю вещественную прямую.

Since 4.13.0

val ceil : float -> float

Округляет вверх до целого значения. ceil f возвращает наименьшее целое значение, большее или равное f. Результат возвращается как число с плавающей точкой.

val floor : float -> float

Округляет вниз до целого значения. floor f возвращает наибольшее целое значение, меньшее или равное f. Результат возвращается как число с плавающей точкой.

val abs_float : float -> float

abs_float f возвращает абсолютное значение f.

val copysign : float -> float -> float

copysign x y возвращает число с плавающей точкой, модуль которого равен модулю x, а знак — знаку x. Если x равно nan, возвращает nan. Если y равно nan, возвращает либо x, либо -. x, но не указано, какое именно.

Since 4.00.0

val mod_float : float -> float -> float

mod_float a b возвращает остаток от деления a на b. Возвращаемое значение равно a -. n *. b, где n — частное a /. b, округлённое к нулю до целого числа.

val frexp : float -> float * int

frexp f возвращает пару мантиссы и порядка f. Когда f равно нулю, мантисса x и порядок n числа f равны нулю. Когда f не равно нулю, они определяются значениями f = x *. 2 ** n и 0.5 <= x < 1.0.

val ldexp : float -> int -> float

ldexp x n возвращает x *. 2 ** n.

val modf : float -> float * float

modf f возвращает пару дробной и целой части f.

val float : int -> float

То же, что и float_of_int.

val float_of_int : int -> float

Преобразовать целое число в число с плавающей точкой.

val truncate : float -> int

То же, что и int_of_float.

val int_of_float : float -> int

Округлить заданное число с плавающей точкой до целого. Результат не определен, если аргумент nan или выходит за пределы диапазона представимых целых чисел.

val infinity : float

Положительная бесконечность.

val neg_infinity : float

Отрицательная бесконечность.

val nan : float

Особое значение с плавающей точкой, обозначающее результат неопределённой операции, такой как 0.0 /. 0.0. Обозначает «не число» (NaN). Любая операция с плавающей точкой с nan в качестве аргумента возвращает nan в качестве результата. Что касается сравнений с плавающей точкой, =, <, <=, > и >= возвращают false, а <> возвращает true, если один или оба аргумента равны nan.

val max_float : float

Наибольшее положительное конечное значение типа float.

val min_float : float

Наименьшее положительное, отличное от нуля и неденормализованное значение типа float.

val epsilon_float : float

Разница между 1.0 и наименьшим точно представимым числом с плавающей точкой, большим чем 1.0.

type fpclass =

`\|`	`FP_normal`	`(*`	Обычное число, ни одно из нижеперечисленных	`*)`
`\|`	`FP_subnormal`	`(*`	Число очень близко к 0.0, точность уменьшена	`*)`
`\|`	`FP_zero`	`(*`	Число равно 0.0 или -0.0	`*)`
`\|`	`FP_infinite`	`(*`	Число равно положительной или отрицательной бесконечности	`*)`
`\|`	`FP_nan`	`(*`	Не число: результат неопределённой операции	`*)`

Пять классов чисел с плавающей запятой, определяемых функцией classify_float.

val classify_float : float -> fpclass

Возвращает класс данного числа с плавающей запятой: нормальное, поднормальное, нулевое, бесконечное или не число.

Операции со строками

Дополнительные операции со строками представлены в модуле String.

val (^) : string -> string -> string

Конкатенация строк. Оператор справа налево, см. Ocaml_operators для получения дополнительной информации.

Возбуждает Invalid_argument если результат длиннее, чем Sys.max_string_length байтов.

Операции с символами

Дополнительные операции с символами представлены в модуле Char.

val int_of_char : char -> int

Возвращает код ASCII аргумента.

val char_of_int : int -> char

Возвращает символ с заданным кодом ASCII.

Возбуждает Invalid_argument если аргумент находится вне диапазона 0--255.

Операции с единицами

val ignore : 'a -> unit

Отбрасывает значение своего аргумента и возвращает (). Например, ignore(f x) отбрасывает результат побочной функции f. Это эквивалентно f x; (), за исключением того, что последнее может сгенерировать предупреждение компилятора; запись ignore(f x) вместо этого предупреждения избегает.

Функции преобразования строк

val string_of_bool : bool -> string

Возвращает строковое представление булевого значения. Поскольку возвращаемые значения могут быть общими, пользователь не должен изменять их напрямую.

val bool_of_string_opt : string -> bool option

Преобразует заданную строку в булево значение.

Возвращает None если строка не "true" или "false".

Since 4.05

val bool_of_string : string -> bool

Аналогично bool_of_string_opt, но возбуждает Invalid_argument "bool_of_string" вместо возврата None.

val string_of_int : int -> string

Возвращает строковое представление целого числа в десятичной форме.

val int_of_string_opt : string -> int option

Преобразуйте заданную строку в целое число. Строка читается в десятичной системе (по умолчанию или если строка начинается с 0u), в шестнадцатеричной (если она начинается с 0x или 0X), в восьмеричной (если она начинается с 0o или 0O) или в двоичной (если она начинается с 0b или 0B).

Префикс 0u читает вход как целое без знака в диапазоне [0, 2*max_int+1]. Если вход превышает max_int, он преобразуется в целое со знаком min_int + input - max_int - 1.

Символ _ (подчеркивание) может появляться где угодно в строке и игнорируется.

Возвращает None если заданная строка не является допустимым представлением целого числа или если представленное целое число выходит за пределы диапазона целых чисел, представимых в типе int.

Since 4.05

val int_of_string : string -> int

Аналогично int_of_string_opt, но вызывает Failure "int_of_string" вместо возвращения None.

val string_of_float : float -> string

Возвращает строковое представление числа с плавающей точкой.

val float_of_string_opt : string -> float option

Преобразуйте заданную строку в число с плавающей точкой. Строка читается в десятичной системе (по умолчанию) или в шестнадцатеричной (отмеченной 0x или 0X).

Формат десятичных чисел с плавающей точкой - [-] dd.ddd (e|E) [+|-] dd , где d обозначает десятичную цифру.

Формат шестнадцатеричных чисел с плавающей точкой - [-] 0(x|X) hh.hhh (p|P) [+|-] dd , где h обозначает шестнадцатеричную цифру, а d - десятичную цифру.

В обоих случаях должна быть указана хотя бы одна из целой и дробной частей; экспоненциальная часть необязательна.

Символ _ (подчеркивание) может появляться где угодно в строке и игнорируется.

В зависимости от платформ исполнения могут приниматься и другие представления чисел с плавающей точкой, но на них полагаться не следует.

Возвращает None если заданная строка не является допустимым представлением числа с плавающей точкой.

Since 4.05

val float_of_string : string -> float

Аналогично float_of_string_opt, но вызывает Failure "float_of_string" вместо возвращения None.

Операции с парами

val fst : 'a * 'b -> 'a

Возвращает первый компонент пары.

val snd : 'a * 'b -> 'b

Возвращает второй компонент пары.

Операции со списками

Дополнительные операции со списками предоставлены в модуле List.

val (@) : 'a list -> 'a list -> 'a list

Конкатенация списков. Не является рекурсивной по хвосту (длина первого аргумента). Оператор правоассоциативный, см. Ocaml_operators для получения дополнительной информации.

Ввод/вывод

Примечание: все функции ввода/вывода могут вызывать Sys_error при сбое системных вызовов, которые они вызывают.

type in_channel

Тип канала ввода.

type out_channel

Тип канала вывода.

val stdin : in_channel

Стандартный ввод для процесса.

val stdout : out_channel

Стандартный вывод для процесса.

val stderr : out_channel

Стандартный вывод ошибок для процесса.

Функции вывода в стандартный вывод

val print_char : char -> unit

Вывод символа в стандартный вывод.

val print_string : string -> unit

Вывод строки в стандартный вывод.

val print_bytes : bytes -> unit

Вывод последовательности байтов в стандартный вывод.

Since 4.02.0

val print_int : int -> unit

Вывод целого числа в десятичной форме в стандартный вывод.

val print_float : float -> unit

Вывод числа с плавающей точкой в десятичной форме в стандартный вывод.

val print_endline : string -> unit

Вывод строки, за которой следует символ новой строки, в стандартный вывод и очистка стандартного вывода.

val print_newline : unit -> unit

Вывод символа новой строки в стандартный вывод и очистка стандартного вывода. Это можно использовать для имитации буферизации строк стандартного вывода.

Функции вывода в стандартный вывод ошибок

val prerr_char : char -> unit

Вывод символа в стандартный вывод ошибок.

val prerr_string : string -> unit

Вывести строку в стандартный поток ошибок.

val prerr_bytes : bytes -> unit

Вывести последовательность байтов в стандартный поток ошибок.

Since 4.02.0

val prerr_int : int -> unit

Вывести целое число в десятичной форме в стандартный поток ошибок.

val prerr_float : float -> unit

Вывести число с плавающей точкой в десятичной форме в стандартный поток ошибок.

val prerr_endline : string -> unit

Вывести строку, за которой следует символ новой строки, в стандартный поток ошибок и очистить стандартный поток ошибок.

val prerr_newline : unit -> unit

Вывести символ новой строки в стандартный поток ошибок и очистить стандартный поток ошибок.

Функции ввода со стандартного ввода

val read_line : unit -> string

Очистить стандартный вывод, затем считать символы со стандартного ввода до тех пор, пока не встретится символ новой строки.

Возвратить строку всех прочитанных символов без символа новой строки в конце.

Raises End_of_file если в начале строки достигнут конец файла.

val read_int_opt : unit -> int option

Очистить стандартный вывод, затем считать одну строку со стандартного ввода и преобразовать её в целое число.

Возвратить None если прочитанная строка не является корректным представлением целого числа.

Since 4.05

val read_int : unit -> int

Аналогично read_int_opt, но поднимает Failure "int_of_string" вместо возвращения None.

val read_float_opt : unit -> float option

Очистить стандартный вывод, затем считать одну строку со стандартного ввода и преобразовать её в число с плавающей точкой.

Возвратить None если прочитанная строка не является корректным представлением числа с плавающей точкой.

Since 4.05.0

val read_float : unit -> float

Аналогично read_float_opt, но поднимает Failure "float_of_string" вместо возвращения None.

Общие функции вывода

type open_flag =

`\|`	`Open_rdonly`	`(*`	открыт для чтения.	`*)`
`\|`	`Open_wronly`	`(*`	открыт для записи.	`*)`
`\|`	`Open_append`	`(*`	открыт для добавления: всегда записывать в конец файла.	`*)`
`\|`	`Open_creat`	`(*`	создать файл, если он не существует.	`*)`
`\|`	`Open_trunc`	`(*`	очистить файл, если он уже существует.	`*)`
`\|`	`Open_excl`	`(*`	не удается, если Open_creat и файл уже существует.	`*)`

`\|`	`Open_binary`	`(*`	Открыть в двоичном режиме (без преобразований).	`*)`
`\|`	`Open_text`	`(*`	Открыть в текстовом режиме (могут выполняться преобразования).	`*)`
`\|`	`Open_nonblock`	`(*`	Открыть в режиме без блокировки.	`*)`

Режимы открытия для open_out_gen и open_in_gen.

val open_out : string -> out_channel

Открыть файл с указанным именем для записи и вернуть новый выходной канал для этого файла, позиционированный в начале файла. Файл усекается до нулевой длины, если он уже существует. Он создается, если не существует.

val open_out_bin : string -> out_channel

То же, что и open_out, но файл открывается в двоичном режиме, чтобы во время записи не происходило никаких преобразований. В операционных системах, не различающих текстовый и двоичный режимы, эта функция ведет себя как open_out.

val open_out_gen : open_flag list -> int -> string -> out_channel

open_out_gen mode perm filename открывает указанный файл для записи, как описано выше. Дополнительный аргумент mode задаёт режим открытия. Дополнительный аргумент perm задаёт права доступа к файлу, в случае его создания. open_out и open_out_bin — это частные случаи этой функции.

val flush : out_channel -> unit

Сбросить буфер, связанный с заданным каналом вывода, выполнив все ожидающие записи в этом канале. В интерактивных программах необходимо следить за своевременным сбросом стандартного вывода и стандартной ошибки.

val flush_all : unit -> unit

Сбросить все открытые каналы вывода; игнорировать ошибки.

val output_char : out_channel -> char -> unit

Записать символ в заданный канал вывода.

val output_string : out_channel -> string -> unit

Записать строку в заданный канал вывода.

val output_bytes : out_channel -> bytes -> unit

Записать последовательность байтов в заданный канал вывода.

Since 4.02.0

val output : out_channel -> bytes -> int -> int -> unit

output oc buf pos len записывает len символов из последовательности байтов buf, начиная с смещения pos, в заданный канал вывода oc.

Raises Invalid_argument если pos и len не обозначают допустимый диапазон buf.

val output_substring : out_channel -> string -> int -> int -> unit

То же, что и output, но в качестве аргумента используется строка вместо последовательности байтов.

Since 4.02.0

val output_byte : out_channel -> int -> unit

Записать целое 8-битное число (как единственный символ с этим кодом) в заданный канал вывода. Заданное целое число берётся по модулю 256.

val output_binary_int : out_channel -> int -> unit

Записать одно целое число в двоичном формате (4 байта, big-endian) в заданный канал вывода. Заданное целое число берётся по модулю 2³². Единственный надёжный способ его повторного чтения — через функцию input_binary_int. Формат совместим на всех машинах для данной версии OCaml.

val output_value : out_channel -> 'a -> unit

Записать представление структурированного значения любого типа в канал. Цикличность и совместное использование внутри значения обнаруживаются и сохраняются. Объект можно прочитать обратно с помощью функции input_value. Для получения дополнительной информации см. описание модуля Marshal. output_value эквивалентно Marshal.to_channel со списком флагов, равным пустому списку.

val seek_out : out_channel -> int -> unit

seek_out chan pos устанавливает текущую позицию записи в pos для канала chan. Это работает только для обычных файлов. Для файлов других типов (например, терминалов, конвейев и сокетов) поведение не определено.

val pos_out : out_channel -> int

Возвращает текущую позицию записи для данного канала. Не работает для каналов, открытых со флагом Open_append (возвращает неопределённые результаты). Для файлов, открытых в текстовом режиме в Windows, возвращаемая позиция является приблизительной (из-за преобразования конца строки); в частности, сохранение текущей позиции с pos_out, а затем возврат к этой позиции с помощью seek_out не будет работать. Для того, чтобы этот фрагмент кода работал надёжно и переносимо, файл необходимо открывать в двоичном режиме.

val out_channel_length : out_channel -> int

Возвращает размер (количество символов) обычного файла, на котором открыт данный канал. Если канал открыт на файле, который не является обычным файлом, результат бессмысленный.

val close_out : out_channel -> unit

Закрывает данный канал, очищая все буферизованные операции записи. Функции вывода возбуждают исключение Sys_error при применении к закрытому каналу вывода, за исключением close_out и flush, которые ничего не делают при применении к уже закрытому каналу. Обратите внимание, что close_out может возбудить исключение Sys_error если операционная система сигнализирует об ошибке при очистке или закрытии.

val close_out_noerr : out_channel -> unit

То же, что и close_out, но игнорирует все ошибки.

val set_binary_mode_out : out_channel -> bool -> unit

set_binary_mode_out oc true устанавливает канал oc в двоичный режим: при выводе переводов не происходит. set_binary_mode_out oc false устанавливает канал oc в текстовый режим: в зависимости от операционной системы, некоторые переводы могут произойти во время вывода. Например, под Windows, символы конца строки будут переведены из \n в \r\n. Эта функция не оказывает никакого влияния на операционных системах, которые не различают текстовый и двоичный режимы.

Общие функции ввода

val open_in : string -> in_channel

Открыть указанный файл для чтения и вернуть новый входной канал для этого файла, размещённый в начале файла.

val open_in_bin : string -> in_channel

То же, что и open_in, но файл открывается в двоичном режиме, поэтому никакие переводы не происходят во время чтения. На операционных системах, которые не различают текстовый и двоичный режимы, эта функция ведет себя как open_in.

val open_in_gen : open_flag list -> int -> string -> in_channel

open_in_gen mode perm filename открывает указанный файл для чтения, как описано выше. Дополнительные аргументы mode и perm задают режим открытия и разрешения файла. open_in и open_in_bin являются частными случаями этой функции.

val input_char : in_channel -> char

Прочитать один символ из данного входного канала.

Возбуждает End_of_file если больше нет символов для чтения.

val input_line : in_channel -> string

Прочитать символы из данного входного канала до тех пор, пока не встретится символ новой строки. Вернуть строку всех прочитанных символов без символа новой строки в конце.

Возбуждает End_of_file если в начале строки достигнут конец файла.

val input : in_channel -> bytes -> int -> int -> int

input ic buf pos len считывает до len символов из заданного канала ic, сохраняя их в последовательности байтов buf, начиная с символа номер pos. Возвращает фактическое количество считанных символов, от 0 до len (включительно). Значение 0 означает, что конец файла достигнут. Значение от 0 до len (исключая) означает, что не все запрошенные len символы были прочитаны, либо потому, что больше символов не было доступно в этот момент, либо потому, что реализация посчитала целесообразным выполнить частичное чтение; необходимо вызвать input снова, чтобы прочитать оставшиеся символы, если это необходимо. (См. также really_input для чтения ровно len символов.) Исключение Invalid_argument "input" возникает, если pos и len не обозначают допустимый диапазон buf.

val really_input : in_channel -> bytes -> int -> int -> unit

really_input ic buf pos len считывает len символов из канала ic, сохраняя их в последовательности байтов buf, начиная с символа номер pos.

Возбуждает
- End_of_file если конец файла достигнут до того, как было прочитано len символов.
- Invalid_argument если pos и len не обозначают допустимый диапазон buf.

val really_input_string : in_channel -> int -> string

really_input_string ic len считывает len символов из канала ic и возвращает их в новой строке.

Since 4.02.0
Возбуждает End_of_file если конец файла достигнут до того, как было прочитано len символов.

val input_byte : in_channel -> int

Аналогично input_char, но возвращает 8-битное целое число, представляющее символ.

Возбуждает End_of_file если был достигнут конец файла.

val input_binary_int : in_channel -> int

Прочитать целое число, закодированное в двоичном формате (4 байта, big-endian), из заданного канала ввода. См. output_binary_int.

Raises End_of_file если при чтении целого числа был достигнут конец файла.

val input_value : in_channel -> 'a

Прочитать представление структурированного значения, созданного функцией output_value, и вернуть соответствующее значение. Эта функция идентична Marshal.from_channel; см. описание модуля Marshal для получения дополнительной информации, особенно относительно отсутствия проверки типов.

val seek_in : in_channel -> int -> unit

seek_in chan pos устанавливает текущую позицию чтения в pos для канала chan. Это работает только для обычных файлов. Для файлов других типов поведение не определено.

val pos_in : in_channel -> int

Возвращает текущую позицию чтения для заданного канала. Для файлов, открытых в текстовом режиме в Windows, возвращаемая позиция приблизительна (из-за преобразования конца строки); в частности, сохранение текущей позиции с помощью pos_in, а затем возврат к этой позиции с помощью seek_in не сработает. Для надежного и переносимого использования этого приема программирования файл должен быть открыт в двоичном режиме.

val in_channel_length : in_channel -> int

Возвращает размер (количество символов) обычного файла, для которого открыт данный канал. Если канал открыт для файла, который не является обычным файлом, результат не имеет смысла. Возвращаемый размер не учитывает преобразования конца строки, которые могут выполняться при чтении из канала, открытого в текстовом режиме.

val close_in : in_channel -> unit

Закрывает заданный канал. Функции ввода вызывают исключение Sys_error при применении к закрытому каналу ввода, за исключением close_in, которое ничего не делает при применении к уже закрытому каналу.

val close_in_noerr : in_channel -> unit

То же, что и close_in, но игнорирует все ошибки.

val set_binary_mode_in : in_channel -> bool -> unit

set_binary_mode_in ic true устанавливает канал ic в двоичный режим: никакие преобразования не выполняются во время ввода. set_binary_mode_out ic false устанавливает канал ic в текстовый режим: в зависимости от операционной системы, некоторые преобразования могут выполняться во время ввода. Например, в Windows символы конца строки будут преобразованы из \r\n в \n. Эта функция не оказывает никакого влияния на операционных системах, не различающих текстовый и двоичный режимы.

Операции с большими файлами

module LargeFile: sig .. end

Операции с большими файлами.

Ссылки

type 'a ref = {

mutable contents : 'a;

}

Тип ссылок (изменяемых косвенных ячеек), содержащих значение типа 'a.

val ref : 'a -> 'a ref

Возвращает свежую ссылку, содержащую заданное значение.

val (!) : 'a ref -> 'a

!r возвращает текущее содержимое ссылки r. Эквивалентно fun r -> r.contents. Унарный оператор, см. Ocaml_operators для получения дополнительной информации.

val (:=) : 'a ref -> 'a -> unit

r := a сохраняет значение a в ссылке r. Эквивалентно fun r v -> r.contents <- v. Оператор с правоассоциативностью, см. Ocaml_operators для получения дополнительной информации.

val incr : int ref -> unit

Инкрементирует целое число, содержащееся в данной ссылке. Эквивалентно fun r -> r := succ !r.

val decr : int ref -> unit

Декрементирует целое число, содержащееся в данной ссылке. Эквивалентно fun r -> r := pred !r.

Тип результата

type ('a, 'b) result =

`\|`	`Ok of 'a`
`\|`	`Error of 'b`

Since 4.03.0

Операции с форматированными строками

Строки формата — это символьные строки со специальными лексическими соглашениями, определяющими функциональность функций форматированного ввода/вывода. Строки формата используются для чтения данных с помощью функций форматированного ввода из модуля Scanf и для вывода данных с помощью функций форматированного вывода из модулей Printf и Format.

Строки формата состоят из трех типов сущностей:

спецификации преобразований, вводимые специальным символом '%' за которым следует один или несколько символов, определяющих тип аргумента для чтения или вывода,
индикаторы форматирования, вводимые специальным символом '@' за которым следует один или несколько символов, определяющих способ чтения или вывода аргумента,
обычные символы — это обычные символы с обычными лексическими соглашениями. Обычные символы задают строковые литералы, которые должны быть прочитаны из входных данных или выведены на выход.

Существует дополнительное лексическое правило для экранирования специальных символов '%' и '@' в строках формата: если специальный символ следует за символом '%', он обрабатывается как обычный символ. Другими словами, "%%" рассматривается как обычный '%' и "%@" как обычный '@'.

Для получения дополнительной информации о спецификациях преобразования и индикаторах форматирования, обратитесь к документации модулей Scanf, Printf и Format.

Строки формата имеют общий и высокополиморфный тип ('a, 'b, 'c, 'd, 'e, 'f) format6. Два упрощенных типа, format и format4 ниже, включены для обратной совместимости с более ранними версиями OCaml.

Значение параметров типа строки формата таково:

'a — это тип параметров формата для функций форматированного вывода (функции стиля printf); 'a — это тип значений, считанных форматом для функций форматированного ввода (функции стиля scanf).

'b — тип источника входных данных для функций форматированного ввода и тип целевого объекта для функций форматированного вывода. Для функций printf-стиля из модуля Printf, 'b обычно out_channel; для функций printf-стиля из модуля Format, 'b обычно Format.formatter; для функций scanf-стиля из модуля Scanf, 'b обычно Scanf.Scanning.in_channel.

Тип аргумента 'b также является типом первого аргумента, переданного пользовательским функциям печати для преобразований %a и %t, и пользовательским функциям чтения для преобразования %r.

'c — тип результата функций печати %a и %t, а также тип аргумента, передаваемого в первый аргумент функций kprintf-стиля или в функции kscanf-стиля.

'd — тип параметров для функций scanf-стиля.

'e — тип целевой функции для функций scanf-стиля.

'f — конечный тип результата вызова функции форматированного ввода/вывода: для функций printf-стиля, обычно unit; для функций scanf-стиля, обычно тип результата целевой функции.

type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6

type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6

type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4

val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string

Преобразует строку формата в строку.

val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 ->       ('a, 'b, 'c, 'd, 'e, 'f) format6

format_of_string s возвращает строку формата, считанную из строковой литералы s. Примечание: format_of_string не может преобразовать строковый аргумент, который не является литералом. Если вам нужна эта функциональность, используйте более общую функцию Scanf.format_from_string.

val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 ->       ('f, 'b, 'c, 'e, 'g, 'h) format6 ->       ('a, 'b, 'c, 'd, 'g, 'h) format6

f1 ^^ f2 конкатенирует форматированные строки f1 и f2. Результатом является форматированная строка, которая ведет себя как конкатенация форматированных строк f1 и f2: в случае форматированного вывода, она принимает аргументы из f1, а затем аргументы из f2; в случае форматированного ввода, она возвращает результаты из f1, а затем результаты из f2. Оператор правоассоциативный, см. Ocaml_operators для более подробной информации.

Окончание программы

val exit : int -> 'a

Завершает процесс, возвращая заданный код состояния операционной системе: обычно 0 для обозначения отсутствия ошибок и небольшое положительное целое число для обозначения сбоя. Все открытые каналы вывода опорожняются с помощью flush_all. Неявное exit 0 выполняется каждый раз, когда программа завершается нормально. Неявное exit 2 выполняется, если программа завершается досрочно из-за необработанного исключения.

val at_exit : (unit -> unit) -> unit

Регистрирует заданную функцию для вызова в момент завершения программы. Функции, зарегистрированные с помощью at_exit, будут вызваны, когда программа выполняет любое из следующих действий:

выполняет exit
завершается нормально или из-за необработанного исключения
выполняет функцию C caml_shutdown. Функции вызываются в порядке «последний вошел, первый вышел»: функция, добавленная последней с помощью at_exit, вызывается первой.

Модули стандартной библиотеки

module Arg: Arg

module Array: Array

module ArrayLabels: ArrayLabels

module Atomic: Atomic

module Bigarray: Bigarray

module Bool: Bool

module Buffer: Buffer

module Bytes: Bytes

module BytesLabels: BytesLabels

module Callback: Callback

module Char: Char

module Complex: Complex

module Digest: Digest

module Either: Either

module Ephemeron: Ephemeron

module Filename: Filename

module Float: Float

module Format: Format

module Fun: Fun

module Gc: Gc

module Genlex: Genlex

module Hashtbl: Hashtbl

module In_channel: In_channel

module Int: Int

module Int32: Int32

module Int64: Int64

module Lazy: Lazy

module Lexing: Lexing

module List: List

module ListLabels: ListLabels

module Map: Map

module Marshal: Marshal

module MoreLabels: MoreLabels

module Nativeint: Nativeint

module Obj: Obj

module Oo: Oo

module Option: Option

module Out_channel: Out_channel

module Parsing: Parsing

module Pervasives: Pervasives

module Printexc: Printexc

module Printf: Printf

module Queue: Queue

module Random: Random

module Result: Result

module Scanf: Scanf

module Seq: Seq

module Set: Set

module Stack: Stack

module StdLabels: StdLabels

module Stream: Stream

module String: String

module StringLabels: StringLabels

module Sys: Sys

module Uchar: Uchar

module Unit: Unit

module Weak: Weak