Модуль String

module String: sig .. end

Строки.

Строка s длины n — это индексируемая и неизменяемая последовательность из n байтов. По историческим причинам эти байты называются символами.

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

positions  0   1   2   3   4    n-1    n
           +---+---+---+---+     +-----+
  indices  | 0 | 1 | 2 | 3 | ... | n-1 |
           +---+---+---+---+     +-----+

Индекс i строки s — это целое число в диапазоне [0;n-1]. Он обозначает i-й байт (символ) строки s, к которому можно обратиться с помощью оператора индексирования строки с постоянным временем выполнения s.[i].
Позиция i строки s — это целое число в диапазоне [0;n]. Она обозначает точку в начале строки, точку между двумя индексами или точку в конце строки. Индекс i-го байта находится между позициями i и i+1.

Два целых числа start и len задают допустимую подстроку строки s, если len >= 0 и start, start+len являются позициями строки s.

Текст в Unicode. Поскольку строки представляют собой произвольные последовательности байтов, они могут содержать текст в любой кодировке. Однако для хранения текста Unicode в строках OCaml рекомендуется кодировка UTF-8. Именно эту кодировку используют Unicode-последовательности экранирования в строковых литералах. Например, строка "\u{1F42B}" — это кодировка символа Unicode U+1F42B в UTF-8.

Изменяемость в прошлом. До OCaml 4.02 строки можно было изменять на месте, как Bytes.t изменяемые последовательности байтов. В OCaml 4 имелись различные флаги компилятора и параметры конфигурации для поддержки перехода от изменяемых строк к неизменяемым. Эти параметры больше недоступны, и теперь строки всегда неизменяемы.

Версию этого модуля с метками можно использовать так, как описано в модуле StdLabels.

Строки

type t = string

Тип строк.

val make : int -> char -> string

make n c — это строка длины n, в которой по каждому индексу находится символ c.

Вызывает исключение Invalid_argument, если n < 0 или n > Sys.max_string_length.

val init : int -> (int -> char) -> string

init n f — это строка длины n, в которой по индексу i находится символ f i (в порядке возрастания индексов).

Начиная с версии 4.02
Вызывает исключение Invalid_argument, если n < 0 или n > Sys.max_string_length.

val empty : string

Пустая строка.

Начиная с версии 4.13

val length : string -> int

length s — это длина (число байтов/символов) строки s.

val get : string -> int -> char

get s i — это символ с индексом i в строке s. Это то же самое, что написать s.[i].

Вызывает исключение Invalid_argument, если i не является индексом строки s.

val of_char : char -> string

of_char c — это c в виде строки.

Начиная с версии 5.5

val of_bytes : bytes -> string

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

Начиная с версии 4.13

val to_bytes : string -> bytes

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

Начиная с версии 4.13

val blit : string -> int -> bytes -> int -> int -> unit

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

Конкатенация

Примечание. Бинарный оператор (^) объединяет две строки.

val concat : string -> string list -> string

concat sep ss объединяет список строк ss, вставляя строку-разделитель sep между каждой парой строк.

Вызывает исключение Invalid_argument, если длина результата превышает Sys.max_string_length байт.

val cat : string -> string -> string

cat s1 s2 объединяет s1 и s2 (s1 ^ s2).

Начиная с версии 4.13
Вызывает исключение Invalid_argument, если длина результата превышает Sys.max_string_length байт.

Предикаты и сравнения

val equal : t -> t -> bool

equal s0 s1 является true тогда и только тогда, когда s0 и s1 посимвольно равны.

Начиная с версии 4.03 (4.05 в StringLabels)

val compare : t -> t -> int

compare s0 s1 упорядочивает s0 и s1 в лексикографическом порядке. compare действует как compare для строк, но может быть эффективнее.

val is_empty : string -> bool

is_empty s является true тогда и только тогда, когда s — пустая строка.

Начиная с версии 5.5

val starts_with : prefix:string -> string -> bool

starts_with ~prefix s является true тогда и только тогда, когда s начинается с prefix.

Начиная с версии 4.13

val ends_with : suffix:string -> string -> bool

ends_with ~suffix s является true тогда и только тогда, когда s заканчивается на suffix.

Начиная с версии 4.13

val includes : affix:string -> string -> bool

includes affix s является true тогда и только тогда, когда affix встречается в s.

Примечание. Если нужно несколько раз проверить одну и ту же строку affix, эффективнее частично применить аргумент ~affix, а затем многократно использовать полученную функцию.

Начиная с версии 5.5

val contains_from : string -> int -> char -> bool

contains_from s start c является true тогда и только тогда, когда c встречается в s после позиции start.

Вызывает исключение Invalid_argument, если start не является допустимой позицией в s.

val rcontains_from : string -> int -> char -> bool

rcontains_from s stop c является true тогда и только тогда, когда c встречается в s до позиции stop+1.

Вызывает исключение Invalid_argument, если stop < 0 или stop+1 не является допустимой позицией в s.

val contains : string -> char -> bool

contains s c — это String.contains_from s 0 c.

Извлечение подстрок

val sub : string -> int -> int -> string

sub s pos len — это строка длины len, содержащая подстроку строки s, которая начинается с позиции pos и имеет длину len.

Вызывает исключение Invalid_argument, если pos и len не задают допустимую подстроку строки s.

Разделение строк

Разделение по величине

val take_first : int -> string -> string

take_first n s — это первые n байт строки s. Это s, если n >= length s, и "", если n <= 0.

Начиная с версии 5.5

val take_last : int -> string -> string

take_last n s — это последние n байт строки s. Это s, если n >= length s, и "", если n <= 0.

Начиная с версии 5.5

val drop_first : int -> string -> string

drop_first n s — это s без первых n байт строки s. Это "", если n >= length s, и s, если n <= 0.

Начиная с версии 5.5

val drop_last : int -> string -> string

drop_last n s — это s без последних n байт строки s. Это "", если n >= length s, и s, если n <= 0.

Начиная с версии 5.5

val cut_first : int -> string -> string * string

cut_first n v — это (take_first n v, drop_first n v).

Начиная с версии 5.5

val cut_last : int -> string -> string * string

cut_last n v — это (drop_last n v, take_last n v).

Начиная с версии 5.5

Разделение по предикатам

val take_first_while : (char -> bool) -> string -> string

take_first_while p s — это начальные последовательные байты строки s, удовлетворяющие предикату p.

Начиная с версии 5.5

val take_last_while : (char -> bool) -> string -> string

take_last_while p s — это конечные последовательные байты строки s, удовлетворяющие предикату p.

Начиная с версии 5.5

val drop_first_while : (char -> bool) -> string -> string

drop_first_while p s — это s без начальных последовательных байтов строки s, удовлетворяющих предикату p.

Начиная с версии 5.5

val drop_last_while : (char -> bool) -> string -> string

drop_last_while p s — это s без конечных последовательных байтов строки s, удовлетворяющих предикату p.

Начиная с версии 5.5

val cut_first_while : (char -> bool) -> string -> string * string

cut_first_while p s — это (take_first_while p s, drop_first_while p s).

Начиная с версии 5.5

val cut_last_while : (char -> bool) -> string -> string * string

cut_last_while p s — это (drop_last_while p s, take_last_while p s).

Начиная с версии 5.5

Разделение по разделителям

Примечание. Если нужно несколько раз разделить одну и ту же строку sep, эффективнее частично применить аргумент ~sep этих функций, а затем многократно использовать полученную функцию.

val split_first : sep:string -> string -> (string * string) option

split_first sep s — это пара Some (left, right), состоящая из двух (возможно, пустых) подстрок строки s, разделённых первым совпадением разделителя sep в s, или None, если sep не найден. Поиск sep начинается с позиции 0 и использует String.find_first.

Если sep равен "", результат — Some ("", s).

Выполняется инвариант concat sep [left; right] = s.

Начиная с версии 5.5

val split_last : sep:string -> string -> (string * string) option

split_last sep s — это пара Some (left, right), состоящая из двух (возможно, пустых) подстрок строки s, разделённых последним совпадением разделителя sep в s, или None, если sep не найден. Поиск sep начинается с позиции length s и использует String.find_last.

Если sep равен "", результат — Some (s, "").

Выполняется инвариант concat sep [left; right] = s.

Начиная с версии 5.5

val split_all : sep:string -> ?drop:(string -> bool) -> string -> string list

split_all sep s — это список всех подстрок строки s, разделённых неперекрывающимися совпадениями разделителя sep, или список [s], если sep не найден. Поиск sep начинается с позиции 0 в порядке возрастания индексов и использует String.find_all.

Подстроки sub, для которых drop sub равно true, не включаются в результат. По умолчанию drop равен Fun.const false.

Если sep равен "", результат — [""; c0; ...; cn; ""], где ci — строка of_char s.[i].

Выполняется инвариант concat sep (split_all sep s) = s.

Начиная с версии 5.5

val rsplit_all : sep:string -> ?drop:(string -> bool) -> string -> string list

rsplit_all sep s — это список всех подстрок строки s, разделённых неперекрывающимися совпадениями разделителя sep, или [s], если sep не найден. Поиск sep начинается с позиции length s в порядке убывания индексов и использует String.rfind_all.

Подстроки sub, для которых drop sub равно true, не включаются в результат. По умолчанию drop равен Fun.const false.

Если sep равен "", результат — [""; c0; ...; cn; ""], где ci — строка of_char s.[i].

Выполняется инвариант concat sep (rsplit_all sep s) = s.

Начиная с версии 5.5

val split_on_char : char -> string -> string list

split_on_char sep s — это список всех (возможно, пустых) подстрок строки s, разделённых символом sep. Если s пуст, результатом будет список из одного элемента [""].

Результат функции задаётся следующими инвариантами:

Список не пуст.
Конкатенация его элементов с использованием sep в качестве разделителя возвращает строку, равную входной строке (concat (make 1 sep) (split_on_char sep s) = s).
Ни одна строка в результате не содержит символ sep.

Начиная с версии 4.04 (4.05 в StringLabels)

Преобразование

val map : (char -> char) -> string -> string

map f s — это строка, полученная применением f ко всем символам строки s в порядке возрастания индексов.

Начиная с версии 4.00

val mapi : (int -> char -> char) -> string -> string

mapi f s подобна String.map, но индекс символа также передаётся в f.

Начиная с версии 4.02

val fold_left : ('acc -> char -> 'acc) -> 'acc -> string -> 'acc

fold_left f x s вычисляет f (... (f (f x s.[0]) s.[1]) ...) s.[n-1], где n — длина строки s.

Начиная с версии 4.13

val fold_right : (char -> 'acc -> 'acc) -> string -> 'acc -> 'acc

fold_right f s x вычисляет f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...)), где n — длина строки s.

Начиная с версии 4.13

val for_all : (char -> bool) -> string -> bool

for_all p s проверяет, удовлетворяют ли все символы строки s предикату p.

Начиная с версии 4.13

val exists : (char -> bool) -> string -> bool

exists p s проверяет, удовлетворяет ли хотя бы один символ строки s предикату p.

Начиная с версии 4.13

val trim : string -> string

trim s — это s без начальных и конечных пробельных символов. К пробельным символам относятся: ' ', '\x0C' (перевод страницы), '\n', '\r' и '\t'.

Начиная с версии 4.00

val escaped : string -> string

escaped s — это s, в которой специальные символы представлены escape-последовательностями согласно лексическим правилам OCaml.

Все символы за пределами печатного диапазона US-ASCII [0x20;0x7E], а также обратная косая черта (0x5C) и двойная кавычка (0x22) заменяются escape-последовательностями.

Функция Scanf.unescaped является левым обратным отображением escaped, то есть Scanf.unescaped (escaped s) = s для любой строки s (если только escaped s не завершается ошибкой).

Вызывает исключение Invalid_argument, если длина результата превышает Sys.max_string_length байт.

val uppercase_ascii : string -> string

uppercase_ascii s — это s, в которой все строчные буквы преобразованы в прописные с использованием набора символов US-ASCII.

Начиная с версии 4.03 (4.05 в StringLabels)

val lowercase_ascii : string -> string

lowercase_ascii s — это s, в которой все прописные буквы преобразованы в строчные с использованием набора символов US-ASCII.

Начиная с версии 4.03 (4.05 в StringLabels)

val capitalize_ascii : string -> string

capitalize_ascii s — это s, в которой первый символ преобразован в прописной с использованием набора символов US-ASCII.

Начиная с версии 4.03 (4.05 в StringLabels)

val uncapitalize_ascii : string -> string

uncapitalize_ascii s — это s, в которой первый символ преобразован в строчной с использованием набора символов US-ASCII.

Начиная с версии 4.03 (4.05 в StringLabels)

Обход

val iter : (char -> unit) -> string -> unit

iter f s последовательно применяет функцию f ко всем символам строки s. Эквивалентно f s.[0]; f s.[1]; ...; f s.[length s - 1]; ().

val iteri : (int -> char -> unit) -> string -> unit

iteri подобна String.iter, но функции также передаётся индекс соответствующего символа.

Начиная с версии 4.00

Поиск индексов

val find_first_index : (char -> bool) -> ?start:int -> string -> int option

find_first_index p start s — это индекс первого символа строки s, удовлетворяющего предикату p, начиная с индекса или позиции start (по умолчанию 0) или после неё.

Если start равен length s, результат всегда равен None.

Начиная с версии 5.5
Вызывает исключение Invalid_argument, если start не является допустимой позицией строки s.

val find_last_index : (char -> bool) -> ?start:int -> string -> int option

find_last_index p start s — это индекс последнего символа строки s, удовлетворяющего предикату p, начиная с индекса или позиции start (по умолчанию length s) или до неё.

Начиная с версии 5.5
Вызывает исключение Invalid_argument, если start не является допустимой позицией строки s.

val index_from : string -> int -> char -> int

index_from s i c — это индекс первого вхождения c в s после позиции i.

Вызывает исключение
- Not_found, если c не встречается в s после позиции i.
- Invalid_argument, если i не является допустимой позицией в s.

val index_from_opt : string -> int -> char -> int option

index_from_opt s i c — это индекс первого вхождения c в s после позиции i (если оно есть).

Начиная с версии 4.05
Вызывает исключение Invalid_argument, если i не является допустимой позицией в s.

val rindex_from : string -> int -> char -> int

rindex_from s i c — это индекс последнего вхождения c в s до позиции i+1.

Вызывает исключение
- Not_found, если c не встречается в s до позиции i+1.
- Invalid_argument, если i+1 не является допустимой позицией в s.

val rindex_from_opt : string -> int -> char -> int option

rindex_from_opt s i c — это индекс последнего вхождения c в s до позиции i+1 (если оно есть).

Начиная с версии 4.05
Вызывает исключение Invalid_argument, если i+1 не является допустимой позицией в s.

val index : string -> char -> int

index s c — это String.index_from s 0 c.

val index_opt : string -> char -> int option

index_opt s c — это String.index_from_opt s 0 c.

Начиная с версии 4.05

val rindex : string -> char -> int

rindex s c — это String.rindex_from s (length s - 1) c.

val rindex_opt : string -> char -> int option

rindex_opt s c — это String.rindex_from_opt s (length s - 1) c.

Начиная с версии 4.05

Поиск подстрок

Примечание. Если нужно несколько раз найти одну и ту же строку sub, эффективнее частично применить аргумент ~sub этих функций, а затем многократно использовать полученную функцию.

val find_first : sub:string -> ?start:int -> string -> int option

find_first sub start s — это начальная позиция первого вхождения sub в s начиная с индекса или позиции start (по умолчанию 0) или после неё.

Если sub равен "", результат равен Some start. Результат функции всегда является допустимым индексом строки s, кроме случая, когда sub равен "", а start равен length s.

Начиная с версии 5.5
Вызывает исключение Invalid_argument, если start не является допустимой позицией строки s.

val find_last : sub:string -> ?start:int -> string -> int option

find_last sub start s — это начальная позиция последнего вхождения sub в s до индекса или позиции start (по умолчанию String.length s) или на ней.

Начиная с версии 5.5
Вызывает исключение Invalid_argument, если start не является допустимой позицией строки s.

val find_all : sub:string -> (int -> 'acc -> 'acc) -> ?start:int -> string -> 'acc -> 'acc

find_all sub f start s acc, начиная с acc, свёртывает f в порядке возрастания индексов по всем неперекрывающимся начальным позициям sub в s начиная с индекса или позиции start (по умолчанию 0) или после неё. Результат равен acc, если sub не удалось найти в s.

Если sub равен "", функция f вызывается для всех позиций строки s начиная с start или после неё.

Начиная с версии 5.5
Вызывает исключение Invalid_argument, если start не является допустимой позицией строки s.

val rfind_all : sub:string -> (int -> 'acc -> 'acc) -> ?start:int -> string -> 'acc -> 'acc

rfind_all sub f start s acc, начиная с acc, свёртывает f в порядке убывания индексов по всем неперекрывающимся начальным позициям sub в s до индекса или позиции start (по умолчанию String.length s) или на ней. Результат равен acc, если sub не удалось найти в s.

Если sub равен "", функция f вызывается для всех позиций строки s до start или на ней.

Начиная с версии 5.5
Вызывает исключение Invalid_argument, если start не является допустимой позицией строки s.

Замена подстрок

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

val replace_first : sub:string -> by:string -> ?start:int -> string -> string

replace_first sub by start s заменяет на by первое вхождение sub в s, начиная с индекса или позиции start (по умолчанию 0).

Если sub — "", функция вставляет by в позицию start.

Начиная с версии 5.5
Вызывает исключение Invalid_argument, если start не является допустимой позицией в s.

val replace_last : sub:string -> by:string -> ?start:int -> string -> string

replace_last sub by start s заменяет на by последнее вхождение sub в s, начиная с индекса или позиции start (по умолчанию String.length s).

Если sub — "", функция вставляет by в позицию start.

Начиная с версии 5.5
Вызывает исключение Invalid_argument, если start не является допустимой позицией в s.

val replace_all : sub:string -> by:string -> ?start:int -> string -> string

replace_all sub by start s заменяет на by все неперекрывающиеся вхождения sub в s, начиная с индекса или позиции start (по умолчанию 0). Вхождения ищутся в порядке возрастания индексов.

Если sub — "", функция вставляет by во все позиции, начиная с start.

Начиная с версии 5.5
Вызывает исключение Invalid_argument, если start не является допустимой позицией в s.

Строки и последовательности

val to_seq : t -> char Seq.t

to_seq s — это последовательность символов строки в порядке возрастания.

Начиная с версии 4.07

val to_seqi : t -> (int * char) Seq.t

to_seqi s работает как String.to_seq, но также включает соответствующий индекс в кортеж.

Начиная с версии 4.07

val of_seq : char Seq.t -> t

of_seq s — это строка, составленная из символов последовательности.

Начиная с версии 4.07

Декодирование и проверка UTF

UTF-8

val get_utf_8_uchar : t -> int -> Uchar.utf_decode

get_utf_8_uchar b i декодирует символ UTF-8 с индексом i в b.

val is_valid_utf_8 : t -> bool

is_valid_utf_8 b имеет значение true тогда и только тогда, когда b содержит корректные данные UTF-8.

UTF-16BE

val get_utf_16be_uchar : t -> int -> Uchar.utf_decode

get_utf_16be_uchar b i декодирует символ UTF-16BE с индексом i в b.

val is_valid_utf_16be : t -> bool

is_valid_utf_16be b имеет значение true тогда и только тогда, когда b содержит корректные данные UTF-16BE.

UTF-16LE

val get_utf_16le_uchar : t -> int -> Uchar.utf_decode

get_utf_16le_uchar b i декодирует символ UTF-16LE с индексом i в b.

val is_valid_utf_16le : t -> bool

is_valid_utf_16le b имеет значение true тогда и только тогда, когда b содержит корректные данные UTF-16LE.

Проверка орфографии

val edit_distance : ?limit:int -> t -> t -> int

edit_distance s0 s1 — это число изменений отдельных символов (вставок, удалений, замен, перестановок), необходимых для преобразования s0 в s1.

Если задано limit, функция возвращает limit сразу после того, как будет установлено, что расстояние между s0 и s1 не меньше limit. Это ускоряет работу, если задан фиксированный предел, например при проверке орфографии.

Функция предполагает, что строки закодированы в UTF-8, и использует Uchar.t в качестве понятия символа. Ошибки декодирования заменяются на Uchar.rep. Нормализация строк до NFC повышает точность результатов.

Примечание. Эта функция реализует более простой алгоритм расстояния Optimal String Alignment (OSA), а не расстояние Дамерау — Левенштейна. С помощью этой функции расстояние между "ca" и "abc" равно 3, а не 2.

Начиная с версии 5.4

val spellcheck : ?max_dist:(string -> int) ->       ((string -> unit) -> unit) -> string -> string list

spellcheck iter_dict s — это строки, перебираемые итератором iter_dict, расстояние редактирования до s которых минимально и не превышает max_dist s. Если возвращено несколько исправлений, они упорядочены так, как встречаются в iter_dict. Значение max_dist s по умолчанию:

0, если s содержит от 0 до 2 символов Unicode.
1, если s содержит от 3 до 4 символов Unicode.
2 в остальных случаях.

Если ваш словарь — список l, подходящее значение iter_dict можно получить с помощью (fun yield -> List.iter yield l).

Предполагается, что все строки закодированы в UTF-8; ошибки декодирования заменяются символами Uchar.rep.

Начиная с версии 5.4

Двоичное декодирование целых чисел

Функции в этом разделе декодируют целые числа из строк в двоичном формате.

Все приведённые ниже функции вызывают исключение Invalid_argument, если символы, необходимые для декодирования целого числа с индексом i, недоступны.

При кодировании с порядком байтов от младшего к старшему (соответственно, от старшего к младшему) сначала сохраняются байты с младшими (соответственно, старшими) значащими разрядами. Порядок от старшего к младшему также известен как сетевой порядок байтов. Порядок байтов, зависящий от платформы, может быть как от младшего к старшему, так и от старшего к младшему в зависимости от значения Sys.big_endian.

32-битные и 64-битные целые числа представлены типами int32 и int64, которые можно интерпретировать как числа со знаком или без знака.

8-битные и 16-битные целые числа представлены типом int, разрядность которого больше, чем у двоичного представления. При декодировании 8-битных или 16-битных целых чисел и представлении их значениями int дополнительные разряды заполняются знаковым битом (или нулями).

val get_uint8 : string -> int -> int

get_uint8 b i — это беззнаковое 8-битное целое число из b, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_int8 : string -> int -> int

get_int8 b i — это знаковое 8-битное целое число из b, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_uint16_ne : string -> int -> int

get_uint16_ne b i — это беззнаковое 16-битное целое число из b с порядком байтов, зависящим от платформы, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_uint16_be : string -> int -> int

get_uint16_be b i — это беззнаковое 16-битное целое число из b с порядком байтов от старшего к младшему, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_uint16_le : string -> int -> int

get_uint16_le b i — это беззнаковое 16-битное целое число из b с порядком байтов от младшего к старшему, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_int16_ne : string -> int -> int

get_int16_ne b i — это знаковое 16-битное целое число из b с порядком байтов, зависящим от платформы, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_int16_be : string -> int -> int

get_int16_be b i — это знаковое 16-битное целое число из b с порядком байтов от старшего к младшему, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_int16_le : string -> int -> int

get_int16_le b i — это знаковое 16-битное целое число из b с порядком байтов от младшего к старшему, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_int32_ne : string -> int -> int32

get_int32_ne b i — это 32-битное целое число из b с порядком байтов, зависящим от платформы, начинающееся с символа с индексом i.

Начиная с версии 4.13

val hash : t -> int

Нехешированная функция хеширования строк, возвращающая то же значение, что и Hashtbl.hash. Эта функция позволяет передавать данный модуль в качестве аргумента функтору Hashtbl.Make.

Начиная с версии 5.0

val seeded_hash : int -> t -> int

Хеш-функция строк с начальным значением, возвращающая то же значение, что и Hashtbl.seeded_hash. Эта функция позволяет передавать данный модуль в качестве аргумента функтору Hashtbl.MakeSeeded.

Начиная с версии 5.0

val get_int32_be : string -> int -> int32

get_int32_be b i — это 32-битное целое число из b с порядком байтов от старшего к младшему, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_int32_le : string -> int -> int32

get_int32_le b i — это 32-битное целое число из b с порядком байтов от младшего к старшему, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_int64_ne : string -> int -> int64

get_int64_ne b i — это 64-битное целое число из b с порядком байтов, зависящим от платформы, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_int64_be : string -> int -> int64

get_int64_be b i — это 64-битное целое число из b с порядком байтов от старшего к младшему, начинающееся с символа с индексом i.

Начиная с версии 4.13

val get_int64_le : string -> int -> int64

get_int64_le b i — это 64-битное целое число из b с порядком байтов от младшего к старшему, начинающееся с символа с индексом i.

Начиная с версии 4.13