Модуль Stdlib

module Stdlib: sig .. end

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

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

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

Исключения

val raise : exn -> 'a

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

val raise_notrace : exn -> 'a

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

Since 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

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

Отладка

val __LOC__ : string

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

Since 4.02.0

val __FILE__ : string

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

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 — последняя позиция символа в строке.

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

Возвращает пару (loc,expr), где (file,lnum,cnum,enum) — кортеж, соответствующий расположению выражения expr в файле, в данный момент парсируемом компилятором. 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

abs x — абсолютное значение x. На min_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, а знак — знаку y. Если 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 в качестве результата. Что касается сравнения с плавающей точкой, =, <, <=, > и >= возвращают 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".

С момента 4.05

val bool_of_string : string -> bool

То же, что и bool_of_string_opt, но вместо возвращения None вызывает исключение Invalid_argument "bool_of_string".

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

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

Это преобразование может привести к потере точности. Для большего контроля над способом вывода числа, обратитесь к Printf.

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

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

Преобразование числа в строку использует string_of_float и может привести к потере точности.

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

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

Преобразование числа в строку использует string_of_float и может привести к потере точности.

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.

Возбуждает 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. Для обратной совместимости с более ранними версиями OCaml включены два упрощенных типа: format и format4.

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

'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. Вызываются обратные вызовы, зарегистрированные с помощью Domain.at_exit, а затем обратные вызовы, зарегистрированные с помощью at_exit.

Неявное 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 Condition: Condition

module Digest: Digest

module Domain: Domain

module Effect: Effect

module Either: Either

module Ephemeron: Ephemeron

module Filename: Filename

module Float: Float

module Format: Format

module Fun: Fun

module Gc: Gc

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 Mutex: Mutex

module Nativeint: Nativeint

module Obj: Obj

module Oo: Oo

module Option: Option

module Out_channel: Out_channel

module Parsing: Parsing

module Printexc: Printexc

module Printf: Printf

module Queue: Queue

module Random: Random

module Result: Result

module Scanf: Scanf

module Semaphore: Semaphore

module Seq: Seq

module Set: Set

module Stack: Stack

module StdLabels: StdLabels

module String: String

module StringLabels: StringLabels

module Sys: Sys

module Uchar: Uchar

module Unit: Unit

module Weak: Weak