Модуль Stdlib

module Stdlib: sig .. end

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

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

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

Исключения

val raise : exn -> 'a

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

val raise_notrace : exn -> 'a

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

Since 4.02

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, совместим с предикатми сравнения =, < и >, определёнными выше, с одним отличием в обработке значения с плавающей запятой nan. А именно, предикаты сравнения рассматривают nan как разные от любого другого значения с плавающей запятой, включая само себя; в то время как compare рассматривает nan как равное самому себе и меньше любого другого значения с плавающей запятой. Такая обработка 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

val __FILE__ : string

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

Since 4.02

val __LINE__ : int

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

Since 4.02

val __MODULE__ : string

__MODULE__ возвращает имя модуля файла, разбираемого компилятором.

Since 4.02

val __POS__ : string * int * int * int

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

Since 4.02

val __FUNCTION__ : string

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

Since 4.12

val __LOC_OF__ : 'a -> string * 'a

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

Since 4.02

val __LINE_OF__ : 'a -> int * 'a

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

Since 4.02

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

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

Since 4.02

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

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

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 для получения дополнительной информации.

Raises 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 для получения дополнительной информации.

Raises 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

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

Десятичный логарифм.

val expm1 : float -> float

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

Since 3.12

val log1p : float -> float

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

Since 3.12

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

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

val asinh : float -> float

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

Since 4.13

val atanh : float -> float

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

Since 4.13

val ceil : float -> float

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

val floor : float -> float

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

val abs_float : float -> float

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

val copysign : float -> float -> float

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

Since 4.00

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 в качестве результата, если не указано иное в стандарте IEEE 754. Что касается сравнений чисел с плавающей точкой, =, <, <=, > и >= возвращают false, а <> возвращает true, если один или оба из их аргументов равны nan.

nan является тихим NaN с версии 5.1; ранее это был сигнализирующий 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, но возбуждает 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.

С 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 если заданная строка не является допустимым представлением числа с плавающей запятой.

С 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

l0 @ l1 добавляет l1 к l0 . Такая же функция, как List.append. Оператор правоассоциативного типа, см. Ocaml_operators для получения дополнительной информации.

С 5.1 эта функция является рекурсивной по хвосту.

Ввод/вывод

Примечание: все функции ввода/вывода могут возбудить 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

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

С 4.02

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

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

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

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

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
Возбуждает 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

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

Форматные строки — это строковые значения с особыми лексическими правилами, определяющими функциональность функций форматированного ввода/вывода. Форматные строки используются для чтения данных с помощью функций форматированного ввода из модуля 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. Вызываются обратные вызовы, зарегистрированные с помощью 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 Dynarray: Dynarray

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

module Uchar: Uchar

module Unit: Unit

module Weak: Weak