Модуль StringLabels

module StringLabels: 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 в строках OCaml является UTF-8. Эта же кодировка используется экранирующими последовательностями Юникода в строковых литералах. Например, строка "\u{1F42B}" является UTF-8 представлением символа Юникода U+1F42B.

Изменяемость в прошлом. До 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 -> f:(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 : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit

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

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

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

val concat : sep: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.05

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 -> pos:int -> len: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 и использует StringLabels.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 и использует StringLabels.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 в порядке возрастания индексов и использует StringLabels.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 в порядке убывания индексов и использует StringLabels.rfind_all.

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

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

С версии 5.5

val split_on_char : sep: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.05

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

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

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

С версии 4.00

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

mapi ~f s работает как StringLabels.map, но функции f также передается индекс символа.

С версии 4.02

val fold_left : f:('acc -> char -> 'acc) -> init:'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 : f:(char -> 'acc -> 'acc) -> string -> init:'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 : f:(char -> bool) -> string -> bool

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

С версии 4.13

val exists : f:(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).

Функция 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.05

val lowercase_ascii : string -> string

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

С версии 4.05

val capitalize_ascii : string -> string

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

С версии 4.05

val uncapitalize_ascii : string -> string

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

С версии 4.05

Обход

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

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

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

iteri работает как StringLabels.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 -> f:(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 -> f:(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 равен "", то в позицию start вставляется by.

Начиная с 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 равен "", то в позицию start вставляется by.

Начиная с 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 работает аналогично StringLabels.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 даёт лучшие результаты.

Примечание. Здесь реализовано более простое расстояние оптимального выравнивания строк (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 символов Юникода.
1, если s содержит от 3 до 4 символов Юникода.
2 в противном случае.

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

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

Начиная с 5.4

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

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

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

Кодирование с прямым порядком байтов (little-endian) (соотв. с обратным порядком байтов (big-endian)) означает, что первыми сохраняются младшие (соотв. старшие) значащие байты. Обратный порядок байтов (big-endian) также известен как сетевой порядок байтов. Собственный порядок байтов (native-endian) является либо прямым, либо обратным в зависимости от 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-разрядное целое число с собственным порядком байтов (native-endian) строки b, начинающееся с индекса символа i.

Начиная с 4.13

val get_uint16_be : string -> int -> int

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

Начиная с 4.13

val get_uint16_le : string -> int -> int

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

Начиная с 4.13

val get_int16_ne : string -> int -> int

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

Начиная с 4.13

val get_int16_be : string -> int -> int

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

Начиная с 4.13

val get_int16_le : string -> int -> int

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

Начиная с 4.13

val get_int32_ne : string -> int -> int32

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

Начиная с 4.13

val hash : t -> int

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

Начиная с 5.0

val seeded_hash : int -> t -> int

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

Начиная с 5.0

val get_int32_be : string -> int -> int32

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

Начиная с 4.13

val get_int32_le : string -> int -> int32

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

Начиная с 4.13

val get_int64_ne : string -> int -> int64

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

Начиная с 4.13

val get_int64_be : string -> int -> int64

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

Начиная с 4.13

val get_int64_le : string -> int -> int64

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

Начиная с 4.13