Standard library reference
The library sits next to the compiler and is written in flang itself. Every function in it goes through the same path your program does: parsing, types, termination, examples. Below is a section per module and a table of all its functions.
использует is the import. A module is attached by name — no path needed:
модуль «Моя программа»
использует «Lists»
The WHOLE module comes in, and the printed code carries all of it. Need a single function — name it:
использует «Lists» только «Сумма»
только does not pull in what the named function calls. Ask for «Двоичный поиск» without «Поиск в диапазоне» and the compiler answers:
FLANG_UNKNOWN_NAME, строка 569, столбец 3: неизвестная функция «Поиск в диапазоне»
FLANG_NOT_TOTAL, строка 569, столбец 3: тотальная функция «Двоичный поиск» вызывает неизвестную функцию «Поиск в диапазоне»: завершение доказать нельзя
Add the missing name after a comma — or take the module whole.
In the tables below, “takes” and “returns” are the signature from the source, word for word. “What it does” is the function’s postcondition — the обеспечивает line of its declaration — also word for word, and in Russian like the code. Hence the author’s turns of phrase inside it: «довод» means argument, «октеты» means bytes.
Where to start
Nine modules cover almost everything written day to day. Each comes with a whole program you can copy and check.
Lists
Lists of any values and lists of numbers: length, slice, range, search, folds, sorting.
Import: использует «Lists».
| function | takes | returns | what it does |
|---|---|---|---|
«Длина» от «А» | элементы: список «А» | число | счёт звеньев сходится со встроенной длиной |
«Приписать в начало» от «А» | первый: «А», элементы: список «А» | список «А» | приписывание удлиняет список ровно на один |
«Соединить списки» от «А» | первый: список «А», второй: список «А» | список «А» | длина соединения есть сумма длин |
«Обратить» от «А» | элементы: список «А» | список «А» | обращение не теряет и не добавляет элементов |
«Отбросить первые» от «А» | элементы: список «А», сколько: число | список «А» | при неположительном сколько не отброшено ничего |
«Взять первые» от «А» | элементы: список «А», сколько: число | список «А» | целое N внутри длины даёт ровно N |
«Срез» от «А» | элементы: список «А», начало: число, конец: число | список «А» | срез от первого до последнего есть весь список |
«Числа до» | предел: число | список числа | предел стоит в промежутке |
«Числа от и до» | начало: число, конец: число | список числа | промежуток, начатый не выше единицы, доходит до конца |
«Элемент» | элементы: список числа, индекс: число | число | на целом номере внутри списка обход сходится со встроенной формой |
«Индекс» | элементы: список числа, значение: число | число | найденное место держит искомое, а ноль значит: не найдено |
«Содержит число» | элементы: список числа, значение: число | признак | встроенная форма и обход по индексу согласны |
«Списки равны» | первый: список числа, второй: список числа | признак | пустому равен только пустой |
«Поиск в диапазоне» | элементы: список числа, цель: число, низ: число, верх: число, витков: неотрицательное | число | отрезок из одного места отдаёт это место, когда оно держит цель |
«Двоичный поиск» | элементы: список числа, цель: число | число | ненулевое место держит цель |
«Все не меньше» | элементы: список числа, порог: число | признак | пустому списку годится любой порог |
«Любой не меньше» | элементы: список числа, порог: число | признак | пустому списку не годится ни один порог |
«Минимум» | элементы: список числа | число | наименьшее взято из самого списка, а на пустом это ноль |
«Максимум» | элементы: список числа | число | наибольшее взято из самого списка, а на пустом это ноль |
«Сумма» | элементы: список числа | число | сумма неотрицательных не меньше наибольшего из них |
«Произведение» | элементы: список числа | число | произведение чисел не меньше единицы не меньше наибольшего из них |
«Вставить по порядку» | значение: число, элементы: список числа | список числа | вставка удлиняет список ровно на один |
«Вставками по порядку» | элементы: список числа | список числа | вставками не теряется и не добавляется ни одного элемента |
«Сортировать» | элементы: список числа | список числа | сортировка не теряет и не добавляет элементов |
«Уникальные» | элементы: список числа | список числа | первый элемент переживает отсев и остаётся первым, а пустой список остаётся пустым |
«Считать вхождения» | элементы: список числа, значение: число | число | счёт не ноль ровно тогда, когда значение в списке |
«Без значения» | элементы: список числа, значение: число | список числа | удалено ровно столько, сколько было вхождений |
«Сжать в пары» | первые: список числа, вторые: список числа | список «Пара чисел» | пар ровно столько, сколько в коротком из списков |
«Сжать суммами» | первые: список числа, вторые: список числа | список числа | сумм ровно столько, сколько в коротком из списков |
A whole program — checked by flang check:
модуль «Проба списков»
использует «Lists»
тотальная функция «Сумма чисел до предела»
принимает предел: число
возвращает число
пример «До пяти»
дано предел равно 5
ожидается 15
«Сумма» от («Числа до» от предел)
Strings
Strings as data: split, replace, case, prefix and suffix, character tests, padding to width.
Import: использует «Strings».
| function | takes | returns | what it does | |
|---|---|---|---|---|
«Приписать строку в начало» | первая: строка, элементы: список строки | список строки | приписывание удлиняет список ровно на один | |
«Соединить строки» | части: список строки, разделитель: строка | строка | склейка начинается первой частью | |
«Разбить по символу» | текст: строка, разделитель: строка | список строки | разбиение даёт хотя бы одну часть | |
«Заменить» | текст: строка, что: строка, чем: строка | строка | кусков по новому разделителю не меньше, чем было по старому | |
«Считать символ» | текст: строка, буква: строка | число | ноль ровно тогда, когда вхождения нет | |
«Позиция подстроки» | текст: строка, часть: строка | число | ноль значит нет вхождения | |
«Начинается с» | текст: строка, префикс: строка | признак | начинается с — это когда кусок ПЕРЕД первым вхождением пуст | |
«Заканчивается на» | текст: строка, суффикс: строка | признак | отрезал суффикс, приклеил обратно — исходное | |
«Заглавная буква» | буква: строка | строка | строчная латинская буква поднимается ровно на 32 кода | |
«Строчная буква» | буква: строка | строка | заглавная латинская буква опускается ровно на 32 кода | |
«В верхний регистр» | текст: строка | строка | верхний регистр не меняет длины | |
«В нижний регистр» | текст: строка | строка | нижний регистр не меняет длины | |
«Символы» | текст: строка | список строки | символов ровно столько, какова длина строки | |
«Обратить строку» | текст: строка | строка | обращение не удлиняет строку | |
«Палиндром» | текст: строка | признак | разложить на знаки и склеить обратно — ответ тот же | |
«Повторить» | текст: строка, раз: число | строка | положительный повтор начинается исходным текстом | |
«Обрезать слева» | текст: строка | строка | приставить обратно отнятые пробелы — получить исходное | |
«Обрезать справа» | текст: строка | строка | дописать обратно отнятые пробелы — получить исходное | |
«Обрезать пробелы» | текст: строка | строка | убраны только пробелы | |
«Первый символ» | текст: строка | строка | первый символ длиной не больше знака | |
«Последний символ» | текст: строка | строка | последний символ длиной не больше знака | |
«Это цифра» | знак: строка | признак | для цифры поиск вхождением и поиск позицией отвечают одно | |
«Это пробел» | знак: строка | признак | для пробела поиск вхождением и поиск позицией отвечают одно | |
«Это латинская буква» | знак: строка | признак | латинская буква — это ровно тот знак, у которого меняется регистр | |
«Только цифры» | текст: строка | признак | убери из текста все десять цифр — у одних цифр не останется ничего | |
«Цифра числом» | знак: строка | число | неотрицательный ответ показывает на тот самый знак | |
«Сколько дополнить» | ширина: неотрицательное, набрано: неотрицательное | число | дополнение — это ровно недостача, а при достатке ноль | |
«Дополнить слева» | текст: строка, ширина: неотрицательное, знак: строка | строка | исходное целиком стоит в дополненном слева | |
«Дополнить справа» | текст: строка, ширина: неотрицательное, знак: строка | строка | дополненное справа начинается исходным | |
«Без знака» | текст: строка, знак: строка | строка | нечего убирать — текст не тронут | |
«Урезать» | текст: строка, предел: неотрицательное | строка | урезанное — начало исходного |
A whole program — checked by flang check:
модуль «Проба строк»
использует «Strings»
тотальная функция «Слово задом наперёд»
принимает текст: строка
возвращает строка
пример «Слово»
дано текст равно " шалаш "
ожидается "шалаш"
«Обратить строку» от («Обрезать пробелы» от текст)
Numbers
Numbers: sign, absolute value, integer division, GCD and LCM, power, factorial, digits.
Import: использует «Numbers».
| function | takes | returns | what it does |
|---|---|---|---|
«Абсолютное значение» | число: число | число | модуль не меньше самого числа и не меньше противоположного ему |
«Знак» | число: число | число | знак читает порядок: у положительного единица, у отрицательного минус единица, у нуля ноль |
«Минимум двух» | первое: число, второе: число | число | минимум — одно из двух чисел и не больше каждого сравнимого с ним |
«Максимум двух» | первое: число, второе: число | число | максимум — одно из двух чисел и не меньше каждого сравнимого с ним |
«Ограничить» | число: число, снизу: число, сверху: число | число | ограничение отдаёт либо само число, либо одну из границ |
«Целочисленное деление» | делимое: число, делитель: число | число | частное и остаток восстанавливают делимое |
«Целая часть» | значение: число | число | целая часть — само число без остатка от единицы |
«Чётное» | число: число | признак | чётность есть делимость на два |
«Делится на» | число: число, делитель: число | признак | делимость — это ровно то, что деление нацело восстанавливает число |
«НОД» | первое: число, второе: число | число | общий делитель и правда делит оба числа |
«НОК» | первое: число, второе: число | число | общее кратное и правда делится на оба числа |
«Степень» | основание: число, показатель: неотрицательное | число | единица в любой степени — единица |
«Факториал» | число: неотрицательное | число | факториал не меньше единицы |
«Цифры» | число: число | список числа | цифра хотя бы одна |
«Сумма цифр» | число: число | число | у однозначного целого сумма цифр — оно само |
A whole program — checked by flang check:
модуль «Проба чисел»
использует «Numbers»
тотальная функция «Доля в процентах»
принимает часть: число, целое: число
возвращает число
пример «Половина»
дано часть равно 1
дано целое равно 2
ожидается 50
«Ограничить» от («Целочисленное деление» от (часть умножить на 100) и целое) и 0 и 100
Optional
A value that may be missing: present or absent, over any type.
Import: использует «Optional».
Types: «Возможно».
| function | takes | returns | what it does |
|---|---|---|---|
«Обернуть» от «А» | значение: «А» | «Возможно» от «А» | обёрнутое значение всегда есть |
«Есть значение» от «А» | опция: «Возможно» от «А» | признак | значение есть ровно тогда, когда опция — не пустая |
«Значение или запасное» от «А» | опция: «Возможно» от «А», запасное: «А» | «А» | у пустой опции берётся запасное, у полной — ровно то, что внутри |
«Первый элемент» от «А» | элементы: список «А» | «Возможно» от «А» | первый элемент есть ровно у непустого списка |
«Первый элемент или запасное» от «А» | элементы: список «А», запасное: «А» | «А» | у пустого списка — запасное, у непустого — ровно первый элемент |
«Последний элемент» от «А» | элементы: список «А» | «Возможно» от «А» | последний элемент есть ровно у непустого списка |
«Последний элемент или запасное» от «А» | элементы: список «А», запасное: «А» | «А» | у пустого списка — запасное, у непустого — ровно последний элемент |
«Найти не меньше» | элементы: список числа, порог: число | «Возможно» от числа | значение есть ровно тогда, когда в списке нашлось не меньшее порога, и оно само не меньше порога |
«Найти не меньше или запасное» | элементы: список числа, порог: число, запасное: число | число | нашли — не меньше порога, не нашли — запасное |
«Умножить значение» | опция: «Возможно» от числа, множитель: число | «Возможно» от числа | умножение не создаёт и не теряет значения |
«Первый удвоенный или запасное» | элементы: список числа, запасное: число | число | первый удваивается, а у пустого списка берётся запасное |
A whole program — checked by flang check:
модуль «Проба опции»
использует «Optional»
тотальная функция «Первое или ноль»
принимает элементы: список числа
возвращает число
пример «Пустой список»
дано элементы равно пустой список
ожидается 0
«Первый элемент или запасное» от элементы и 0
Result
The outcome of a computation: success with a value, or an error with a reason.
Import: использует «Result».
Types: «Результат».
| function | takes | returns | what it does |
|---|---|---|---|
«Успешный результат» от «Значение» и «Беда» | значение: «Значение» | «Результат» от «Значение» и «Беда» | успешный результат успешен |
«Ошибочный результат» от «Значение» и «Беда» | сообщение: «Беда» | «Результат» от «Значение» и «Беда» | ошибочный результат не успешен |
«Успешно» от «Значение» и «Беда» | итог: «Результат» от «Значение» и «Беда» | признак | успех узнаётся по варианту, и только по нему |
«Успех или запасное» от «Значение» и «Беда» | итог: «Результат» от «Значение» и «Беда», запасное: «Значение» | «Значение» | у успеха берётся ровно его значение, у ошибки — запасное |
«Сообщение или пусто» от «Значение» | итог: «Результат» от «Значение» и строки | строка | у успеха сообщение пусто, у ошибки — ровно её сообщение |
«Безопасное деление» | делимое: число, делитель: число | «Результат» от числа и строки | деление успешно ровно при ненулевом делителе |
«Деление или запасное» | делимое: число, делитель: число, запасное: число | число | нулевой делитель даёт запасное, прочий — частное |
«Сообщение деления» | делимое: число, делитель: число | строка | сообщение есть ровно на нулевом делителе |
«Разобрать цифру» | текст: строка | «Результат» от числа и строки | разбор успешен ровно на одиночной цифре |
«Цифра или запасное» | текст: строка, запасное: число | число | цифра разбирается в своё число, прочее даёт запасное |
«Ошибка разбора» | текст: строка | строка | сообщение называет причину: не одна — так не цифра |
A whole program — checked by flang check:
модуль «Проба результата»
использует «Result»
тотальная функция «Деление на ноль не роняет»
принимает делимое: число, делитель: число
возвращает число
пример «Ноль в делителе»
дано делимое равно 10
дано делитель равно 0
ожидается -1
«Деление или запасное» от делимое и делитель и -1
Higher order
Functions as values: map, filter, fold, sort by your own order.
Import: использует «Higher order».
| function | takes | returns | what it does |
|---|---|---|---|
«Удвоить» | х: число | число | удвоение есть сложение с самим собой |
«Возвести в квадрат» | х: число | число | квадрат есть умножение на самого себя |
«Утроить» | х: число | число | утроение есть умножение на три |
«Противоположное» | х: число | число | противоположное складывается с исходным в ноль, пока это число |
«Положительное» | х: число | признак | положительно то, что больше нуля пересиливает |
«Сложить» | первое: число, второе: число | число | слагаемые можно переставить |
«Умножить» | первое: число, второе: число | число | сомножители можно переставить |
«Меньшее» | первое: число, второе: число | число | меньшее и большее вместе дают ту же сумму |
«Большее» | первое: число, второе: число | число | на строгом неравенстве отдаётся то из двух, что больше |
«По возрастанию» | первое: число, второе: число | признак | порядок вперёд есть порядок назад с переставленными доводами |
«По убыванию» | первое: число, второе: число | признак | на строгом неравенстве порядок назад решается однозначно |
«Свернуть» | ф: функция из числа и числа в число, основа: число, элементы: список числа | число | на пустом списке свёртка есть само основание |
«Отобразить» от «А» и «Б» | ф: функция из «А» в «Б», элементы: список «А» | список «Б» | отображение сохраняет длину списка |
«Отфильтровать» от «А» | условие: функция из «А» в признак, элементы: список «А» | список «А» | подходящий первый элемент отбор не теряет |
«Считать где» | условие: функция из числа в признак, элементы: список числа | число | счёт подходящих есть длина отобранного |
«Все» | условие: функция из числа в признак, элементы: список числа | признак | все подходят ровно тогда, когда подходящих столько же, сколько элементов |
«Любой» | условие: функция из числа в признак, элементы: список числа | признак | хоть один подходит ровно тогда, когда подходящих не меньше одного |
«Найти первое» | условие: функция из числа в признак, элементы: список числа, запасное: число | число | всё, что не запасное, подходит |
«Позиция где» | условие: функция из числа в признак, элементы: список числа | число | на найденном месте стоит подходящее, а ноль значит: не найдено |
«Вставить по» | раньше: функция из числа и числа в признак, значение: число, элементы: список числа | список числа | вставка удлиняет список ровно на один |
«Сортировать по» | раньше: функция из числа и числа в признак, элементы: список числа | список числа | сортировка по порядку не теряет и не добавляет элементов |
«Сортировать по направлению» | убывание: признак, элементы: список числа | список числа | сортировка не теряет и не добавляет элементов |
«Составить» | внешняя: функция из числа в число, внутренняя: функция из числа в число, х: число | число | состав есть два отображения подряд |
«Отобразить составом» | внешняя: функция из числа в число, внутренняя: функция из числа в число, элементы: список числа | список числа | отображение составом сохраняет длину списка |
«Сжать» | ф: функция из числа и числа в число, первые: список числа, вторые: список числа | список числа | сжато ровно столько, сколько в коротком из списков |
«Сумма сложением» | элементы: список числа | число | сумма положительных не меньше наибольшего из них |
«Произведение умножением» | элементы: список числа | число | произведение одного элемента есть он сам |
«Минимум меньшим из двух» | элементы: список числа | число | наименьшее взято из самого списка, а на пустом это ноль |
«Максимум большим из двух» | элементы: список числа | число | наибольшее взято из самого списка, а на пустом это ноль |
«Обратить знаки» | элементы: список числа | список числа | обращение знаков сохраняет длину списка |
«Заглавная точка» | текст: строка | строка | точка удлиняет строку ровно на один знак |
«Непустая» | текст: строка | признак | непустая — та, чья длина положительна |
A whole program — checked by flang check:
модуль «Проба высшего порядка»
использует «Higher order»
тотальная функция «Сумма квадратов»
принимает элементы: список числа
возвращает число
пример «Три числа»
дано элементы равно [1, 2, 3]
ожидается 14
«Свернуть» от функция «Сложить» и 0 и («Отобразить» от функция «Возвести в квадрат» и элементы)
Dictionary
A string → string map built as a list of pairs. Lookup is linear: a thousand keys behave like a thousand-element list.
Import: использует «Dictionary».
Types: «Связь».
| function | takes | returns | what it does |
|---|---|---|---|
«Ключ связи» | связь: «Связь» | строка | ключ связи — это ключ, записанный в связи |
«Значение связи» | связь: «Связь» | строка | значение связи — это значение, записанное в связи |
«Есть ключ» | словарь: список «Связь», искомый: строка | признак | ключ найден ровно тогда, когда он есть среди ключей |
«Взять или запасное» | словарь: список «Связь», искомый: строка, запасное: строка | строка | чего нет среди ключей, того и не взято: отдаётся запасное |
«Убрать» | словарь: список «Связь», искомый: строка | список «Связь» | удаление не удлиняет словарь |
«Положить» | словарь: список «Связь», ключ: строка, значение: строка | список «Связь» | после записи словарь непуст |
«Ключи» | словарь: список «Связь» | список строки | ключей ровно столько, сколько связей |
«Значения» | словарь: список «Связь» | список строки | значений ровно столько, сколько связей |
«Размер» | словарь: список «Связь» | число | размер словаря неотрицателен |
A whole program — checked by flang check:
модуль «Проба словаря»
использует «Dictionary»
тотальная функция «Значение по ключу связью»
принимает ключ: строка
возвращает строка
пример «Ключа нет»
дано ключ равно "рост"
ожидается "нет"
пусть словарь равно («Положить» от пустой список и "цвет" и "синий")
«Взять или запасное» от словарь и ключ и "нет"
Hash map
A string → string map with constant-time access: a trie over hash digits.
Import: использует «Hash map».
Types: «Звено», «Узел хеша».
| function | takes | returns | what it does |
|---|---|---|---|
«Ключ звена» | звено: «Звено» | строка | ключ звена — это ключ, записанный в звене |
«Значение звена» | звено: «Звено» | строка | значение звена — это значение, записанное в звене |
«В кольцо» | значение: число | число | кольцо неотрицательно |
«Хеш числа» | значение: число | число | хеш числа неотрицателен |
«Хеш ключа» | ключ: строка | число | хеш ключа неотрицателен |
«Путь хеша» | хеш: число | список числа | путь хеша — ровно четырнадцать ступеней |
«Гнездо» | звенья: список «Звено», спуск: число | «Узел хеша» | гнездо держит ровно те звенья, что дали, и не глубже одного уровня |
«Слить звенья» | первые: список «Звено», вторые: список «Звено» | список «Звено» | длина слияния есть сумма длин |
«Вписать» | звенья: список «Звено», новое: «Звено» | список «Звено» | после вписывания список звеньев непуст |
«Развести» | путь: список числа, первые: список «Звено», спуск: число, вторые: список «Звено», прежний: число | «Узел хеша» | разведение не теряет и не двоит: звеньев ровно столько, сколько дали |
«Вложить» | узел: «Узел хеша», спуск: число, новое: «Звено» | «Узел хеша» | вложенное по спуску по тому же спуску и находится |
«Искать» | узел: «Узел хеша», спуск: число, искомый: строка, запасное: строка | строка | где признака нет, поиск отдаёт запасное |
«Искать признак» | узел: «Узел хеша», спуск: число, искомый: строка | признак | в пустом месте ключей нет, одиночка отвечает по своему ключу, а пустая гроздь всегда молчит |
«Положить в словарь» | словарь: «Узел хеша», ключ: строка, значение: строка | «Узел хеша» | положенное по ключу тем же ключом и находится |
«Найти в словаре» | словарь: «Узел хеша», искомый: строка, запасное: строка | строка | чего в словаре нет, за то отдаётся запасное |
«Есть ключ в словаре» | словарь: «Узел хеша», искомый: строка | признак | ключ есть ровно тогда, когда поиск не отдаёт запасное — и всё равно какое |
«Звенья словаря» | словарь: «Узел хеша» | список «Звено» | у пустого места звеньев нет, у одиночки ровно одно и своё, у грозди — весь её набор |
«Размер словаря» | словарь: «Узел хеша» | число | размер — это сколько у словаря ключей |
«Ключи словаря» | словарь: «Узел хеша» | список строки | ключей ровно столько, сколько звеньев |
«Значения словаря» | словарь: «Узел хеша» | список строки | значений ровно столько, сколько звеньев |
«Больше из двух» | слева: число, справа: число | число | больше из двух — одно из двух |
«Глубина словаря» | словарь: «Узел хеша» | число | где есть звенья, там есть и глубина |
«Словарь из ключей» | ключи: список строки | «Узел хеша» | ни один поданный ключ не потерялся |
A whole program — checked by flang check:
модуль «Проба словаря хешем»
использует «Hash map»
тотальная функция «Значение по ключу»
принимает ключ: строка
возвращает строка
пример «Ключ найден»
дано ключ равно "цвет"
ожидается "синий"
пусть словарь равно («Положить в словарь» от («Словарь из ключей» от пустой список) и "цвет" и "синий")
«Найти в словаре» от словарь и ключ и "нет"
JSON
JSON as a value: tokenizing, parsing, printing. It never touches the outside world.
Import: использует «JSON».
Types: «Значение json», «Поле json», «Итог json», «Знак json», «Разметка json», «Счёт json», «Исход числа json», «Рамка json», «Ход json».
| function | takes | returns | what it does |
|---|---|---|---|
«Имя поля json» | пара: «Поле json» | строка | имя поля — это записанное в поле имя |
«Содержимое поля json» | пара: «Поле json» | «Значение json» | содержимое поля — это записанное в поле значение |
«Беда разметки json» | разметка: «Разметка json» | строка | беда разметки — это записанная в состоянии беда |
«Знаки разметки json» | разметка: «Разметка json» | список «Знак json» | знаки разметки — это записанный в состоянии список знаков |
«Сломать разметку json» | разметка: «Разметка json», причина: строка | «Разметка json» | сломанная разметка не бывает без причины |
«Пробельный json» | симв: строка | признак | пробельны ровно четыре знака, и ровно по одному |
«Цифра json» | симв: строка | признак | цифра — ровно тот знак, у которого значение цифры лежит в 0..9 |
«Значение цифры json» | симв: строка | число | значение цифры — код первого знака без сорока восьми, и пустая строка ведёт себя как ноль |
«Шестнадцатеричная json» | симв: строка | признак | шестнадцатеричны ровно двадцать два знака набора |
«Буква слова json» | симв: строка | признак | буквы слов — ровно те, из которых сложены true, false и null |
«Одиночный знак json» | симв: строка | признак | одиночны ровно шесть знаков разметки |
«Начало счёта json» | ничего: строка | «Счёт json» | свежий счёт ещё ничего не прочёл: этап начальный, знаки положительны, целое и дробь нули |
«Шаг счёта json» | счёт: «Счёт json», симв: строка | «Счёт json» | сбой липкий: из сорванного этапа счёт не выходит и цифр больше не набирает |
«Десять в степени json» | показатель: число | число | степень десяти положительна |
«Число из текста json» | текст: строка | «Исход числа json» | пустой текст числом не разбирается |
«Начало разметки json» | ничего: строка | «Разметка json» | свежая разметка пуста во всех пяти полях |
«Добавить знак json» | разметка: «Разметка json», знак: «Знак json» | «Разметка json» | беда липкая: к сломанной разметке знак не добавляется |
«Копить json» | разметка: «Разметка json», лад: строка, добавка: строка, хвост: строка | «Разметка json» | беда липкая: сломанная разметка не копит |
«Закрыть лексему json» | разметка: «Разметка json» | «Разметка json» | беда липкая: сломанную разметку закрытие не трогает |
«Знак вне json» | разметка: «Разметка json», симв: строка | «Разметка json» | беда липкая: сломанная разметка знаков не читает |
«Шаг разметки json» | разметка: «Разметка json», симв: строка | «Разметка json» | беда липкая: сломанная разметка дальше не идёт |
«Знаки json» | текст: строка | «Разметка json» | у целой разметки лексема всегда закрыта: лад и копилка пусты |
«Начало хода json» | ничего: строка | «Ход json» | свежий ход ждёт значения: стопка и готовое пусты, изъяна нет |
«Сломать ход json» | ход: «Ход json», причина: строка | «Ход json» | изъян липкий: первую причину вторая не затирает |
«Вписать поле json» | набор: список «Поле json», новое: «Поле json» | список «Поле json» | в пустой набор поле встаёт одно и со своим именем |
«Вложить значение json» | ход: «Ход json», значение: «Значение json» | «Ход json» | изъян липкий: сломанный ход значений не берёт |
«Закрыть рамку json» | ход: «Ход json», квадратной: признак | «Ход json» | изъян липкий: сломанный ход рамок не закрывает |
«Верх это массив json» | стопка: список «Рамка json» | признак | пустая рамка массива наверху — это массив |
«Записать ключ json» | ход: «Ход json», имя: строка | «Ход json» | ключ вне объекта — названный изъян |
«Шаг разбора json» | ход: «Ход json», знак: «Знак json» | «Ход json» | изъян липкий: сломанный разбор дальше не идёт |
«Разобрать json» | текст: строка | «Итог json» | пустой вход отвергается с названной причиной |
«Шестнадцатеричная цифра json» | значение: число | строка | цифра — ровно один знак |
«Заслонить знак json» | симв: строка | строка | заслонение не укорачивает и пусто ровно на пустом |
«Напечатать строку json» | текст: строка | строка | печать строки — кавычки плюс не меньше знаков, чем было |
«Напечатать json» | значение: «Значение json» | строка | напечатанное значение непусто |
A whole program — checked by flang check:
модуль «Проба json»
использует «JSON»
тотальная функция «Разобрать и напечатать»
принимает текст: строка
возвращает строка
пример «Массив печатается обратно»
дано текст равно "[1,2]"
ожидается "[1,2]"
разбор («Разобрать json» от текст)
случай вариант «Разобран json» с значение как значение
то «Напечатать json» от значение
случай вариант «Не разобран json» с причина как причина
то причина
Written most recently
Five modules are younger than the rest. For each one: what it can do and what it cannot.
| Module | Can | Cannot |
|---|---|---|
«AES» | Encrypts and decrypts with AES-128: a single block, a stream in CTR mode, GCM with tag creation and verification. | No keys longer than 128 bits, and no key generation — take the key from the key-derivation or X25519 module. |
«X25519» | Computes a shared key for two sides: multiplies a Curve25519 point by a scalar — both the base point and the other side’s public key. | No Ed25519 signatures, and no randomness: the secret arrives as an argument. |
«DER» | Reads DER: tag, length, contents, nested sequences, integers, strings and object identifiers. | There is no DER writing — reading only. |
«X.509» | Takes a certificate out of PEM and reads version, serial number, issuer and subject, validity and the signature algorithm name; answers whether it is valid on a given day. | It does not parse the public key or extensions, does not verify the signature, does not build a chain and does not read revocation. |
«База SQLite» | Reads a database file: header, page size, pages and cells, records, column values, table names from the schema and the rows of a table by name. | There is no writing — reading only. SQL is not parsed: a table is taken by name, and you write the condition yourself. |
AES
The AES-128 cipher: a single block, counter mode (CTR) and GCM with tag verification.
Import: использует «AES».
Types: «Ход шифра», «Ход счёта», «Ход гаммы», «Ход поля», «Ход сдвига», «Ход GHASH», «Ход гаммы GCM», «Печать GCM», «Исход GCM».
| function | takes | returns | what it does | |
|---|---|---|---|---|
«Веса байта» | — | список числа | разрядов ровно восемь | |
«Исключающее или байтов» | первый: число, второй: число | число | итог — байт снизу | |
«Байт по номеру» | байты: список числа, номер: число | число | байт по номеру — байт сверху | |
«Таблица подстановки» | — | список числа | в таблице ровно двести пятьдесят шесть байтов | |
«Подстановка» | байт: число | число | подстановка — байт | |
«Удвоить в поле» | байт: число | число | удвоенное — байт | |
«Утроить в поле» | байт: число | число | утроенное — байт | |
«Четыре байта» | байты: список числа, смещение: число | список числа | слово — ровно четыре байта | |
«Шестнадцать байтов» | байты: список числа, смещение: число | список числа | блок — ровно шестнадцать байтов | |
«Сложить слова» | первое: список числа, второе: список числа | список числа | сумма слов — четыре байта | |
«Постоянные раундов» | — | список числа | постоянных ровно десять | |
«Слово поворота» | слово: список числа, постоянная: число | список числа | итог — четыре байта | |
«Шаг расширения» | расширение: список числа, постоянная: число | список числа | шаг дописывает ровно шестнадцать байтов | |
«Расширение ключа» | ключ: список числа | список числа | расширение — сто семьдесят шесть байтов, одиннадцать ключей раунда | |
«Подстановка блока» | квадрат: список числа | список числа | подстановка длины не меняет | |
«Сдвиг строк» | квадрат: список числа | список числа | сдвиг даёт ровно шестнадцать байтов | |
«Смешать столбец» | б0: число, б1: число, б2: число, б3: число | список числа | смешанный столбец — четыре байта | |
«Смешать столбцы» | квадрат: список числа | список числа | смешение даёт ровно шестнадцать байтов | |
«Сложить с ключом» | квадрат: список числа, ключ: список числа | список числа | сложение даёт ровно шестнадцать байтов | |
«Ключ раунда» | расширение: список числа, раунд: число | список числа | ключ раунда — шестнадцать байтов | |
«Шаг раунда шифра» | ход: «Ход шифра», раунд: число | «Ход шифра» | раунд шифра ключа не трогает | |
«Состояние хода» | ход: «Ход шифра» | список числа | квадрат хода — то самое квадрат | |
«Зашифровать блок» | ключ: список числа, блок: список числа | список числа | шифроблок ровно той же длины, что и блок, — шестнадцать байтов | |
«Шаг счёта» | ход: «Ход счёта», байт: число | «Ход счёта» | счёт удлиняет ответ ровно на байт | |
«Байты счёта» | ход: «Ход счёта» | список числа | байты счёта — те самые байты | |
«Прибавить единицу» | счётчик: список числа | список числа | счётчик CTR остаётся блоком в шестнадцать байтов | |
«Шаг гаммы» | ход: «Ход гаммы», байт: число | «Ход гаммы» | выход гаммы удлиняется ровно на байт | |
«Выход гаммы» | ход: «Ход гаммы» | список числа | выход хода гаммы — тот самый выход | |
«Шифр CTR» | ключ: список числа, счётчик: список числа, текст: список числа | список числа | шифротекст CTR ровно той же длины, что и открытый текст | |
«Сложить блоки» | первый: список числа, второй: список числа | список числа | сумма блоков — ровно шестнадцать байтов | |
«Многочлен поля» | — | список числа | многочлен — блок в шестнадцать байтов | |
«Шаг сдвига блока» | ход: «Ход сдвига», байт: число | «Ход сдвига» | сдвиг удлиняет ответ ровно на байт | |
«Байты сдвига» | ход: «Ход сдвига» | список числа | байты сдвига — те самые байты | |
«Сдвиг блока вправо» | блок: список числа | список числа | сдвиг не меняет длины | |
«Привести сдвиг» | блок: список числа | список числа | приведение не меняет длины | |
«Шаг разряда поля» | ход: «Ход поля», бит: число | «Ход поля» | произведение разряда остаётся блоком | |
«Шаг байта поля» | ход: «Ход поля», байт: число | «Ход поля» | произведение байта остаётся блоком | |
«Произведение поля» | ход: «Ход поля» | список числа | произведение хода — то самое накопленное | |
«Умножить в поле» | первый: список числа, второй: список числа | список числа | произведение — блок в шестнадцать байтов | |
«Шаг GHASH» | ход: «Ход GHASH», байт: число | «Ход GHASH» | — | |
«Свод GHASH» | ход: «Ход GHASH» | список числа | — | |
«GHASH» | ключ: список числа, данные: список числа | список числа | — | |
«Ключ хеша» | ключ: список числа | список числа | ключ поля — блок в шестнадцать байтов | |
«Прибавить единицу по младшим четырём» | счётчик: список числа | список числа | счётчик GCM остаётся блоком в шестнадцать байтов | |
«Шаг гаммы GCM» | ход: «Ход гаммы GCM», байт: число | «Ход гаммы GCM» | выход гаммы GCM удлиняется ровно на байт | |
«Выход гаммы GCM» | ход: «Ход гаммы GCM» | список числа | выход хода гаммы GCM — тот самый выход | |
«Шифр GCTR» | ключ: список числа, счётчик: список числа, текст: список числа | список числа | шифротекст GCTR ровно той же длины, что и открытый текст | |
«Набивка до блока» | байты: список числа | список числа | набитое нулями делится на блоки нацело | |
«Данные GHASH» | доп: список числа, шифротекст: список числа | список числа | данные делятся на блоки нацело | |
«Начальный счётчик» | ключ: список числа, вектор: список числа | список числа | начальный счётчик — блок в шестнадцать байтов | |
«Тег GCM» | ключ: список числа, вектор: список числа, доп: список числа, шифротекст: список числа | список числа | тег GCM — ровно шестнадцать байтов | |
«Зашифровать GCM» | ключ: список числа, вектор: список числа, доп: список числа, текст: список числа | «Печать GCM» | тег шифрования GCM — ровно шестнадцать байтов | |
«Расшифровано ли» | исход: «Исход GCM» | признак | успех признаётся успехом | |
«Текст исхода» | исход: «Исход GCM» | список числа | у отказа текста нет | |
«Расшифровать GCM» | ключ: список числа, вектор: список числа, доп: список числа, шифротекст: список числа, тег: список числа | «Исход GCM» | при отказе открытого текста не выдаётся | |
«Байт двумя знаками» | байт: число | строка | байт печатается ровно двумя знаками | |
«Байты шестнадцатеричной строкой» | байты: список числа | строка | на каждый байт — по два знака |
X25519
X25519 key exchange on Curve25519 — RFC 7748.
Import: использует «X25519».
Types: «Ход переноса», «Ход займа», «Ход лестницы».
| function | takes | returns | what it does | |
|---|---|---|---|---|
«Нули» | сколько: число | список числа | три нуля | |
«Разряд» | разряды: список числа, номер: число | число | второй разряд | |
«Взять первые» | разряды: список числа, сколько: число | список числа | первые два | |
«Отбросить первые» | разряды: список числа, сколько: число | список числа | без первых двух | |
«Сложить по разрядам» | первые: список числа, вторые: список числа | список числа | длина суммы — длина длинного из слагаемых | |
«Добавить к первому» | разряды: список числа, добавка: число | список числа | добавка ложится на младший разряд | |
«Шаг переноса» | ход: «Ход переноса», разряд: число | «Ход переноса» | — | |
«Разложить» | разряды: список числа | «Ход переноса» | — | |
«Ужать» | разряды: список числа | список числа | — | |
«Свести» | разряды: список числа | список числа | сведение не меняет числа разрядов, пока их шестнадцать | |
«Ноль поля» | — | список числа | ноль поля — шестнадцать разрядов | |
«Единица поля» | — | список числа | единица поля — шестнадцать разрядов | |
«Простое поля» | — | список числа | простое поля — шестнадцать разрядов | |
«Четыре простых» | — | список числа | четыре простых — шестнадцать разрядов | |
«Из байтов» | байты: список числа | список числа | из тридцати двух байтов выходит шестнадцать разрядов | |
«Точка из байтов» | байты: список числа | список числа | шестнадцать разрядов из тридцати двух байтов | |
«В байты» | разряды: список числа | список числа | на каждый разряд по два байта | |
«Снять старший» | разряды: список числа | список числа | — | |
«Вычесть с займом» | первые: список числа, вторые: список числа, заём: число | «Ход займа» | — | |
«Канон» | разряды: список числа | список числа | шестнадцать разрядов, пока их было шестнадцать | |
«Это ноль» | разряды: список числа | признак | ноль | |
«Это единица» | разряды: список числа | признак | единица | |
«Сложение» | а: список числа, б: список числа | список числа | сумма — те же шестнадцать разрядов | |
«Вычитание» | а: список числа, б: список числа | список числа | разность — те же шестнадцать разрядов | |
«Свёртка разрядов» | а: список числа, б: список числа | список числа | двойка на тройку | |
«Свернуть разряды» | разряды: список числа | список числа | — | |
«Умножение» | а: список числа, б: список числа | список числа | произведение полей — те же шестнадцать разрядов | |
«Квадрат» | а: список числа | список числа | квадрат — те же шестнадцать разрядов | |
«Умножить на число» | а: список числа, множитель: число | список числа | произведение на число — те же шестнадцать разрядов | |
«Квадраты» | а: список числа, сколько: число | список числа | ни одного квадрата — само число | |
«Обращение» | а: список числа | список числа | обращённое — те же шестнадцать разрядов | |
«Веса байта» | — | список числа | восемь весов | |
«Бит скаляра» | скаляр: список числа, номер: число | число | младший бит девятки | |
«Зажать скаляр» | байты: список числа | список числа | байтов столько же, сколько было | |
«Шаг лестницы» | ход: «Ход лестницы», точка: список числа, бит: число | «Ход лестницы» | — | |
«Лестница» | скаляр: список числа, точка: список числа, ход: «Ход лестницы», осталось: число | «Ход лестницы» | — | |
«Умножить точку» | скаляр: список числа, точка: список числа | список числа | результат — ровно тридцать два байта | |
«Основание» | — | список числа | тридцать два байта | |
«Открытый ключ» | тайна: список числа | список числа | открытый ключ — ровно тридцать два байта |
DER
Parsing DER — the binary ASN.1 encoding from X.690, the one certificates are written in.
Import: использует «DER».
| function | takes | returns | what it does |
|---|---|---|---|
«Октет» | октеты: список числа, место: число | число | за концом списка октет нулевой |
«Шаг куска» | ход: «Ход куска», октет: число, начало: число, конец: число | «Ход куска» | номер подвинулся ровно на один |
«Ход по куску» | октеты: список числа, начало: число, конец: число | «Ход куска» | пройден весь список, номер стал длиной плюс один |
«Кусок» | октеты: список числа, начало: число, конец: число | список числа | кусок не длиннее целого |
«Делить нацело» | делимое: число, делитель: число | число | деление на ноль даёт ноль, а не бесконечность |
«Разобрать меру» | октеты: список числа, место: число | «Мера DER» | у меры без беды хотя бы один октет длины |
«Число из октетов» | октеты: список числа | число | пустая цепочка октетов даёт ноль |
«Разобрать голову» | октеты: список числа, место: число | «Голова DER» | конец не раньше начала |
«Собрать голову» | октеты: список числа, место: число, мера: «Мера DER» | «Голова DER» | беда меры переходит в беду головы |
«Содержимое» | октеты: список числа, место: число | список числа | содержимое не длиннее всего разбираемого |
«Шаг обхода» | ход: «Обход DER», октеты: список числа, конец: число | «Обход DER» | обход не пятится |
«Шаг вперёд» | ход: «Обход DER», голова: «Голова DER», конец: число | «Обход DER» | беда головы останавливает обход на конце |
«Ход по вложенным» | октеты: список числа, место: число | «Обход DER» | вложенных не больше, чем всех октетов, и обход не пятится назад |
«Вложенные» | октеты: список числа, место: число | список числа | вложенных не больше, чем октетов во всём разбираемом |
«Вложенное по счёту» | октеты: список числа, место: число, номер: число | число | место вложенного либо ноль, либо лежит внутри октетов |
«Целое DER» | октеты: список числа | число | пустое целое равно нулю |
«Цифра 16» | н: число | строка | цифра — ровно один знак |
«Октет шестнадцатеричным» | октет: число | строка | октет печатается ровно двумя знаками |
«Октеты шестнадцатеричным» | октеты: список числа | строка | на каждый октет ровно два знака |
«Октеты двоеточиями» | октеты: список числа | строка | пустое даёт пустое |
«Знак октета» | октет: число | строка | знак всегда ровно один |
«Строка DER» | октеты: список числа | строка | на каждый октет ровно один знак |
«Закрыть узел OID» | ход: «Ход OID», значение: число | «Ход OID» | после закрытия узла копилка пуста |
«Шаг OID» | ход: «Ход OID», октет: число | «Ход OID» | узел закрывается ровно на октете без старшего бита |
«Идентификатор объекта» | октеты: список числа | строка | пустой идентификатор печатается пустым |
«Цифра октета» | октет: число | число | не цифра даёт ноль |
«Двузначное» | октеты: список числа, место: число | число | двузначное меньше ста |
«Разобрать время» | метка: число, октеты: список числа | «Время DER» | у времени без беды год не меньше тысяча девятьсот пятидесятого |
«Название месяца» | месяц: число | строка | название месяца — ровно три знака |
«Два знака» | н: число | строка | ровно два знака |
«Время как у openssl» | время: «Время DER» | строка | печать времени непуста |
«Время числом» | время: «Время DER» | число | время числом неотрицательно |
X.509
Parsing an X.509 certificate — RFC 5280: fields, names, validity, key.
Import: использует «X.509».
| function | takes | returns | what it does | |
|---|---|---|---|---|
«Строка не окаймление» | строчка: строка | признак | окаймление начинается с дефиса | |
«Тело PEM» | текст: строка | строка | тело не длиннее исходного текста | |
«Октеты сертификата из PEM» | текст: строка | список числа | октетов сертификата не больше, чем знаков в его тексте | |
«Место тела сертификата» | октеты: список числа | число | тело сертификата начинается не раньше третьего октета | |
«Сдвиг версии» | октеты: список числа | число | сдвиг версии сертификата — ноль или один, третьего не бывает | |
«Место поля тела» | октеты: список числа, номер: число | число | место поля тела сертификата лежит внутри октетов или равно нулю | |
«Короткое имя атрибута» | опр: строка | строка | имя атрибута непусто, если непуст сам идентификатор | |
«Печать пары имени» | октеты: список числа, место: число | строка | пара печатается со знаком равенства | |
«Печать набора имени» | октеты: список числа, место: число | строка | печать набора не длиннее трёх знаков на октет | |
«Печать имени» | октеты: список числа, место: число | строка | печать имени не длиннее трёх знаков на октет | |
«Версия сертификата» | октеты: список числа | число | версия сертификата — от первой до третьей | |
«Октеты серийного номера» | октеты: список числа | список числа | серийный номер не длиннее всего сертификата | |
«Серийный номер» | октеты: список числа | строка | серийный номер печатается не длиннее трёх знаков на октет сертификата | |
«Имя алгоритма» | опр: строка | строка | имя алгоритма непусто, если непуст идентификатор | |
«Алгоритм подписи» | октеты: список числа | строка | имя алгоритма подписи непусто у непустого сертификата | |
«Издатель» | октеты: список числа | строка | издатель печатается не длиннее, чем весь сертификат знаками | |
«Субъект» | октеты: список числа | строка | субъект печатается не длиннее, чем весь сертификат знаками | |
«Место срока» | октеты: список числа | число | место срока не отрицательно | |
«Не ранее» | октеты: список числа | «Время DER» | у времени начала срока месяц не больше двенадцати | |
«Не позднее» | октеты: список числа | «Время DER» | у времени конца срока месяц не больше двенадцати | |
«Сертификат просрочен» | октеты: список числа, сейчас: число | признак | до конца срока сертификат не просрочен | |
«Сертификат ещё не начался» | октеты: список числа, сейчас: число | признак | после начала срока сертификат уже начался | |
«Сертификат действует» | октеты: список числа, сейчас: число | признак | действующий сертификат не позднее своего конца срока |
SQLite
Reading a SQLite 3 database file: header, pages, cells, values.
Import: использует «SQLite».
Types: «Варинт», «Сбор варинтов», «Сбор указателей», «Значение», «Ряд», «Таблица».
| function | takes | returns | what it does |
|---|---|---|---|
«Отбросить октеты» | октеты: список числа, сколько: число | список числа | отброшено не больше, чем было |
«Взять октеты» | октеты: список числа, сколько: число | список числа | взято не больше, чем было |
«Кусок октетов» | октеты: список числа, смещение: число, сколько: число | список числа | кусок не длиннее заказанного и не длиннее источника |
«Целое из октетов» | октеты: список числа | число | пустые октеты дают ноль |
«Целое у смещения» | октеты: список числа, смещение: число, ширина: число | число | целое неотрицательно, пока октеты неотрицательны |
«Текст октетов» | октеты: список числа | строка | пустые октеты дают пустой текст |
«Магия базы» | — | строка | магия названа целиком |
«Это база SQLite» | октеты: список числа | признак | короче магии — не база |
«Размер страницы» | октеты: список числа | число | размер страницы у настоящей базы не меньше пятисот двенадцати |
«Страниц в базе» | октеты: список числа | число | страниц ровно столько, сколько их влезает в файл, пока заголовок не врёт |
«Страница» | октеты: список числа, номер: число | список числа | страница начинается не позже конца файла и не длиннее остатка файла |
«Смещение заголовка страницы» | номер: число | число | сто на первой странице, ноль на всякой другой |
«Вид страницы» | страница: список числа, номер: число | число | вид неотрицателен |
«Это лист таблицы» | страница: список числа, номер: число | признак | лист таблицы — это ровно вид 13 |
«Ячеек на странице» | страница: список числа, номер: число | число | ячеек не больше, чем указателей влезает в страницу |
«Длина заголовка страницы» | вид: число | число | восемь у листьев, двенадцать у внутренних |
«Шаг указателя» | ход: «Сбор указателей», октет: число | «Сбор указателей» | первый октет пары только копится, второй даёт указатель |
«Указатели из октетов» | октеты: список числа | список числа | указателей ровно половина от числа октетов, когда их чётно |
«Указатели ячеек» | страница: список числа, номер: число | список числа | указателей ровно столько, сколько ячеек названо заголовком страницы |
«Варинт из октетов» | октеты: список числа, набрано: число, взято: число | «Варинт» | варинт съедает хотя бы один октет и не больше девяти |
«Взять варинт» | октеты: список числа | «Варинт» | на пустом входе не взято ничего |
«Шаг варинта» | ход: «Сбор варинтов», октет: число | «Сбор варинтов» | замыкающий октет добавляет ровно одно число, продолжающий — ни одного |
«Варинты подряд» | октеты: список числа | список числа | варинтов не больше, чем октетов |
«Ширина по типу» | серийный: число | число | ширина неотрицательна |
«Значение по типу» | серийный: число, октеты: список числа | «Значение» | ничто выходит ровно у серийного типа 0 |
«Значения записи» | типы: список числа, тело: список числа | список «Значение» | значений ровно столько, сколько серийных типов |
«Разобрать запись» | нагрузка: список числа | список «Значение» | значений ровно столько, сколько серийных типов в заголовке записи |
«Строка ячейки» | страница: список числа, указатель: число | «Ряд» | номер строки неотрицателен |
«Строки листа» | страница: список числа, номер: число | список «Ряд» | строк выдано ровно столько, сколько ячеек на листе |
«Строки страницы» | октеты: список числа, номер: число | список «Ряд» | пустая база строк не даёт |
«Строки схемы» | октеты: список числа | список «Ряд» | строк схемы ровно столько, сколько ячеек на первой странице |
«Текст значения» | значение: «Значение» | строка | у нетекстового значения текста нет |
«Число значения» | значение: «Значение» | число | у нецелого значения числа нет |
«Колонка строки» | ряд: «Ряд», номер: число | «Значение» | за пределами строки — ничто |
«Таблица из строки схемы» | ряд: «Ряд» | «Таблица» | корень неотрицателен |
«Таблицы схемы» | октеты: список числа | список «Таблица» | таблиц не больше, чем ячеек на странице-схеме |
«Имена таблиц» | октеты: список числа | список строки | имён ровно столько, сколько таблиц |
«Корень таблицы» | октеты: список числа, имя: строка | число | корень неотрицателен, а ноль значит: такой таблицы нет |
«Строки таблицы» | октеты: список числа, имя: строка | список «Ряд» | у ненайденной таблицы строк нет |
«Значение строкой» | значение: «Значение» | строка | целое печатается числом |
«Строка текстом» | ряд: «Ряд» | строка | печать непуста, пока в строке есть хоть одно значение |
The module reads октеты — the list of bytes of the file. It cannot open a file and is not meant to: the bytes are brought in by a plan. A plan is a program that hands one piece of work with the world at a time to the host (flang io) and gets a reply back; here there is one order — «Прочитать октеты из файла».
Make a sample file with a third-party sqlite3, so there is something to check against. The page size is set explicitly so that the numbers below match yours:
python3 -c "import sqlite3; c=sqlite3.connect('база.db'); \
c.execute('pragma page_size=1024'); c.execute('vacuum'); \
c.execute('create table люди(имя text, лет integer)'); \
c.executemany('insert into люди values (?,?)', [('Аня',31),('Боря',44),('Вера',7)]); \
c.commit()"
модуль «Заголовок базы»
использует «SQLite»
тип «Ход»
вариант «Начало»
вариант «Ждём октеты»
тотальная функция «Начало хода»
возвращает «Ход»
вариант «Начало»
тотальная функция «Отчёт»
принимает октеты: список числа
возвращает строка
соединить [
"это база SQLite: ", (если («Это база SQLite» от октеты) то "да" иначе "нет"),
"\nразмер страницы: ", (к строке («Размер страницы» от октеты)),
"\nстраниц: ", (к строке («Страниц в базе» от октеты)),
"\nтаблицы: ", (соединить («Имена таблиц» от октеты) по ", ")
] по ""
тотальная функция «Дальше»
принимает ход: «Ход», отклик: «Отклик»
возвращает «Продолжение»
разбор ход
случай вариант «Начало»
то вариант «Сделать» с поручение равным (вариант «Прочитать октеты из файла» с путь равным "база.db") и потом равным (вариант «Ждём октеты»)
случай вариант «Ждём октеты»
то разбор отклик
случай вариант «Октеты» с октеты как октеты
то вариант «Конец работы» с значение равным («Отчёт» от октеты)
случай любое
то вариант «Провал» с код равным "FLANG_IO_ORDER" и сообщение равным "ждали октетов"
план «Заголовок»
состояние «Ход»
начинает с «Начало хода»
обрабатывает «Дальше»
flang io заголовок.flang
{"plan":"Заголовок","result":"это база SQLite: да\nразмер страницы: 1024\nстраниц: 2\nтаблицы: люди","orders":1}
What this module will not give you today. The header, the schema and the table names read fine; on row values the evaluation runs into the step limit. The plan examples/db/sqlite-read.flang, which also prints the rows of a table, answers this on a 2 KiB database:
FLANG_RECURSION_LIMIT: функция «Кодовые точки из байтов» исчерпала лимит шагов (10000000) на глубине вызовов 19
UTF-8 decoding walks one byte at a time by recursion, and starts over on every cell. While that is so, read the header and the schema through this module, not the contents.
The rest of the modules
Key derivation
Deriving a key from a password: PBKDF2-HMAC-SHA256, RFC 8018.
Import: использует «Key derivation».
Types: «Ход вывода».
| function | takes | returns | what it does |
|---|---|---|---|
«Дописать номер» | меньшие: список числа, байтов: число | список числа | граница куска — номер дописывается |
«Номера кусков» | байтов: неотрицательное | список числа | кусков хватает на заказанную длину |
«Шаг витка» | пароль: список числа, ход: «Ход вывода» | «Ход вывода» | — |
«Витки вывода» | пароль: список числа, ход: «Ход вывода», осталось: число | «Ход вывода» | — |
«Итог витков» | ход: «Ход вывода» | список числа | — |
«Кусок вывода» | пароль: список числа, соль: список числа, повторов: число, номер: число | список числа | кусок — ровно тридцать два байта |
«Вывод ключа» | пароль: список числа, соль: список числа, повторов: число, байтов: неотрицательное | список числа | ключ ровно заказанной длины |
Date and time
Dates and times as values: ISO-8601 parsing, addition, difference, leap years, weekdays. It never asks what time it is — time arrives as an argument.
Import: использует «Date and time».
Types: «Календарный день», «Часы», «Отметка», «Итог даты».
| function | takes | returns | what it does |
|---|---|---|---|
«Пол дроби» | значение: число | число | на конечном числе пол цел, не больше входа и отстоит не дальше единицы |
«Деление вниз» | делимое: число, делитель: число | число | деление вниз — это пол частного |
«Високосный год» | год: число | признак | високосный год — тот, в котором 366 дней |
«Дней в месяце» | год: число, месяц: число | число | в месяце не больше 31 дня |
«Дата верна» | дата: «Календарный день» | признак | дата верна ровно тогда, когда круг через счёт дней её не меняет |
«Часы верны» | часы: «Часы» | признак | время верно ровно тогда, когда напечатанные ЧЧ:ММ:СС читаются обратно в границах суток |
«Дней от эпохи» | дата: «Календарный день» | число | отсчёт привязан к эпохе: 1970-01-01 — ноль, следующий день — единица, предыдущий — минус единица |
«Дата из дней» | дни: число | «Календарный день» | дата, собранная из дня, тем же днём и отсчитывается |
«День недели» | дата: «Календарный день» | число | день недели не больше шести |
«Имя дня недели» | номер: неотрицательное | строка | у всякого дня недели имя есть, и оно от пяти до одиннадцати букв |
«День года» | дата: «Календарный день» | число | у верной даты день года лежит между первым и триста шестьдесят шестым |
«Прибавить дни» | дата: «Календарный день», сколько: число | «Календарный день» | между исходной датой и сдвинутой ровно столько дней, сколько прибавили |
«Разность дат» | первая: «Календарный день», вторая: «Календарный день» | число | даты, отстоящие на целое число недель, приходятся на один день недели |
«Секунд от эпохи» | отметка: «Отметка» | число | эпоха на нуле, полдень на 43200, а тот же полдень в поясе плюс три — на 32400 |
«Раньше» | первая: «Отметка», вторая: «Отметка» | признак | что раньше по мгновению, то раньше и по ответу, и с одновременностью это не совмещается |
«Одно мгновение» | первая: «Отметка», вторая: «Отметка» | признак | совпали секунды — совпало и мгновение, как бы ни были записаны пояса |
«Число из цифр» | текст: строка | число | пустая строка даёт минус единицу, а число из пятнадцати цифр не длиннее своей записи |
«Смещение из хвоста» | хвост: строка | число | шестизначная запись пояса разбирается и печатается той же записью, а плюс с ненулевым часом даёт положительное смещение |
«Разобрать отметку» | текст: строка | «Итог даты» | отметка короче десяти знаков отвергается с названной причиной |
«Двумя знаками» | значение: число | строка | двумя знаками — это ровно два знака, пока число целое |
«Четырьмя знаками» | значение: число | строка | четырёхзначное целое печатается четырьмя знаками и читается обратно собой |
«Напечатать дату» | дата: «Календарный день» | строка | печать даты не короче десяти знаков, а ровно десять — это ГГГГ-ММ-ДД |
«Напечатать пояс» | смещение: число | строка | ноль печатается буквой Z, а целое смещение до 23:59 — знаком, часами и минутами, читаемыми обратно |
«Напечатать отметку» | отметка: «Отметка» | строка | печать отметки не короче двадцати знаков, а ровно двадцать — это запись со всемирным поясом |
Requests and responses
The pure half of HTTP: parsing and printing requests and responses, headers, status codes, URLs, percent-encoding.
Import: использует «Requests and responses».
Types: «Заголовок», «Запрос», «Ответ», «Разбор запроса», «Разбор заголовков», «Разбор тела», «Длина тела», «Целое из строки», «Ход раскодирования».
| function | takes | returns | what it does |
|---|---|---|---|
«Склеить куски» | части: список строки, разделитель: строка | строка | склейка содержит первый кусок |
«Первый кусок» | части: список строки | строка | у пустого списка первого куска нет, а у непустого он — его голова |
«Прочие куски» | части: список строки | список строки | прочих ровно на один меньше |
«Обрезать пробельные знаки слева» | текст: строка | строка | слева снят край, и снят он только тогда, когда там пробел |
«Обрезать пробельные знаки справа» | текст: строка | строка | справа снят край, и снят он только тогда, когда там пробел |
«Перевернуть» | текст: строка | строка | пустое переворачивается в пустое, один знак — в себя, а два знака меняются местами |
«Обрезать края» | текст: строка | строка | обрезка краёв есть обрезка справа после обрезки слева |
«Строчный код» | код: число | число | заглавная латинская буква переезжает в нижний регистр ровно на тридцать два, всё прочее не двигается, пока это число |
«Имена совпадают» | первое: строка, второе: строка | признак | имена разной длины не совпадают, а две пустые совпадают |
«Цифра десятичная» | код: число | число | разбор цифры обратен таблице шестнадцати |
«Цифра шестнадцатеричная» | код: число | число | разбор шестнадцатеричной обратен таблице шестнадцати |
«Целое из десятичной» | текст: строка | «Целое из строки» | пустая строка числом не является, одна цифра даёт своё значение, а один нецифровой знак — отказ |
«Целое из шестнадцатеричной» | текст: строка | «Целое из строки» | пустая строка размером не является, а одна шестнадцатеричная цифра даёт своё значение |
«Знак по коду» | код: число | строка | знак по коду есть ровно тогда, когда код в таблице, и его код — тот самый |
«Цифра в шестнадцатеричную» | н: число | строка | шестнадцатеричная цифра — ровно один знак |
«Байт процентами» | байт: число | строка | байт процентами — ровно три знака |
«Незарезервированный» | код: число | признак | буква и тильда незарезервированы, а пробел и разделители адреса — зарезервированы |
«Знак процентами» | знак: строка | строка | пустой знак даёт пустое, незарезервированный не трогается, а прочий однобайтовый становится тройкой с процентом впереди |
«Точка процентами» | точка: число | строка | на каждый октет UTF-8 по три знака, и октетов от одного до четырёх |
«Закодировать проценты» | текст: строка | строка | кодирование процентами не укорачивает |
«Свести байт» | собрано: строка, байт: число, сырое: строка | «Ход раскодирования» | сведение байта закрывает ожидание, а собранное растёт: печатный байт даёт один знак, непечатный возвращает сырую запись целиком |
«Шаг раскодирования» | ход: «Ход раскодирования», знак: строка | «Ход раскодирования» | процент вне ожидания начинает ожидание двух цифр и запоминается сырым |
«Раскодировать проценты» | текст: строка | строка | текст без процента раскодированием не меняется |
«Плюсы в пробелы» | текст: строка | строка | замена плюсов сохраняет длину |
«Путь цели» | цель: строка | строка | путь и строка запроса покрывают цель без остатка |
«Строка запроса цели» | цель: строка | строка | строка запроса — весь хвост после первого вопроса |
«Разобрать пару» | кусок: строка | «Заголовок» | кусок без равенства даёт имя из всего куска и пустое значение |
«Разобрать параметры» | строказапроса: строка | список «Заголовок» | строка запроса без амперсанда и с непустым именем даёт ровно один параметр, и это та же пара |
«Имя заголовка» | заголовок: «Заголовок» | строка | имя заголовка — это записанное в нём имя |
«Значение заголовка» | заголовок: «Заголовок» | строка | значение заголовка — это записанное в нём значение |
«Сколько заголовков» | заголовки: список «Заголовок», имя: строка | число | столько заголовков, сколько их отбирается по имени |
«Взять заголовок» | заголовки: список «Заголовок», имя: строка | строка | у пустого списка заголовка нет, а на одном заголовке берётся его значение ровно при совпадении имён |
«Есть заголовок» | заголовки: список «Заголовок», имя: строка | признак | заголовок есть ровно тогда, когда отбор по имени непуст |
«Шаг заголовков» | прежнее: «Разбор заголовков», строка: строка | «Разбор заголовков» | негодный блок заголовков негодным и остаётся: первую беду вторая не затирает |
«Разобрать заголовки» | строки: список строки | «Разбор заголовков» | пустой список строк даёт пустой блок заголовков, а одна строка без двоеточия — названную негодность |
«Длина тела» | заголовки: список «Заголовок» | «Длина тела» | без заголовка длина не названа, а при двух заголовках она негодна с названной причиной |
«Тело чанками» | заголовки: список «Заголовок» | признак | один заголовок передачи со значением chunked объявляет чанки |
«Чанки с запасом» | остаток: строка, запас: число, собрано: строка | «Разбор тела» | исчерпанный запас — названная порча |
«Собрать чанки» | текст: строка | «Разбор тела» | пустой текст запаса не даёт и потому объявляется испорченным, а один нулевой чанк закрывает пустое тело |
«Голый перевод строки» | голова: строка | признак | в пустом блоке голых переводов нет, одиночные перевод и возврат — голые, а пара из них — нет |
«Есть длинная строка» | строки: список строки, предел: число | признак | у пустого списка длинных строк нет, а одна строка длинна ровно тогда, когда длиннее предела |
«Свести тело» | метод: строка, цель: строка, версия: строка, заголовки: список «Заголовок», сырое: строка | «Разбор запроса» | длина тела и чанки, объявленные разом, — названная порча |
«Собрать запрос» | голова: строка, сырое: строка | «Разбор запроса» | голый перевод строки в голове отвергает запрос названной причиной |
«Разобрать запрос» | текст: строка | «Разбор запроса» | вход без пустой строки между головой и телом — неполон, и отвечать на него нечем |
«Пояснение кода» | код: число | строка | известные коды получают свои слова, неизвестный — пустое |
«Код успешен» | код: число | признак | успешны ровно те коды, у которых пояснение из двухсотых |
«Напечатать заголовки» | заголовки: список «Заголовок» | строка | на каждый заголовок не меньше четырёх знаков: двоеточие, пробел и конец строки |
«Напечатать ответ» | ответ: «Ответ» | строка | печать начинается версией, кодом и пояснением, а длина тела в ней названа по самому телу |
«Ответ с телом» | код: число, тело: строка | «Ответ» | ответ несёт свой код, пояснение по коду, ровно один заголовок вида и то самое тело |
«Ответ на разбор» | разобранное: «Разбор запроса» | строка | неполному и разобранному запросу не отвечают вовсе, а испорченному отвечают его же кодом и его же причиной |
«Напечатать запрос» | запрос: «Запрос» | строка | печать начинается методом, целью и версией, а длина тела в ней названа по самому телу |
«Куски пути» | путь: строка | список строки | кусков ровно столько, сколько непустых частей пути |
«Глубина пути» | путь: строка | число | глубина — число непустых частей пути |
«Кусок пути» | путь: строка, номер: число | строка | номер меньше единицы куска не даёт, а первый кусок пути — это голова его разбиения |
«Значение параметра» | параметры: список «Заголовок», имя: строка | строка | у пустого списка значения нет, а первый параметр с в точности тем же именем отдаёт своё значение, даже пустое |
«Есть параметр» | параметры: список «Заголовок», имя: строка | признак | параметр есть ровно тогда, когда имя встретилось хоть раз |
«Схема адреса» | адрес: строка | строка | схема — ровно то, что стоит перед :// |
«Адрес годен» | адрес: строка | признак | годен ровно тот адрес, у которого схема http или https |
Logic
Operations over booleans: and, or, not, exclusive or, implication, plus “all true” and “any true” over a list.
Import: использует «Logic».
| function | takes | returns | what it does |
|---|---|---|---|
«Оба верны» | первый: признак, второй: признак | признак | конъюнкция читается и со второго довода: при истинном втором ответ есть первый, при ложном — ложь |
«Хотя бы одно» | первый: признак, второй: признак | признак | дизъюнкция читается и со второго довода: при истинном втором ответ истина, при ложном — первый |
«Не так» | значение: признак | признак | отрицание есть импликация в ложь |
«Ровно одно» | первый: признак, второй: признак | признак | исключающее или есть неравенство признаков |
«Следует» | посылка: признак, следствие: признак | признак | импликация есть отрицание посылки или следствие |
«Все верны» | значения: список признака | признак | все верны ровно тогда, когда ложного среди значений нет |
«Есть верное» | значения: список признака | признак | есть верное ровно тогда, когда истинное среди значений есть |
String sets
A set of strings: add, remove, union, intersection, difference, subset.
Import: использует «String sets».
| function | takes | returns | what it does |
|---|---|---|---|
«Есть в множестве» | множество: список строки, искомое: строка | признак | есть в множестве — это встроенная проверка вхождения |
«Добавить в множество» | множество: список строки, новое: строка | список строки | добавление не укорачивает множество |
«Убрать из множества» | множество: список строки, лишнее: строка | список строки | удаление не удлиняет множество |
«Из списка» | элементы: список строки | список строки | множество из списка не длиннее списка |
«Объединение» | первое: список строки, второе: список строки | список строки | объединение не короче первого множества |
«Пересечение» | первое: список строки, второе: список строки | список строки | пересечение не длиннее первого множества |
«Разность» | первое: список строки, второе: список строки | список строки | разность не длиннее уменьшаемого |
«Подмножество» | меньшее: список строки, большее: список строки | признак | подмножество — это когда лишних элементов нет |
«Размер множества» | множество: список строки | число | размер множества неотрицателен |
Base64
Base64 per RFC 4648: the standard alphabet and the URL-safe one.
Import: использует «Base64».
Types: «Ход кодирования 64», «Ход раскодирования 64».
| function | takes | returns | what it does |
|---|---|---|---|
«Азбука 64» | — | строка | в азбуке ровно 64 знака |
«Азбука 64 для адреса» | — | строка | в азбуке для адреса тоже ровно 64 знака |
«Знак 64» | шестёрка: число | строка | знак азбуки — ровно один знак |
«Знак 64 для адреса» | шестёрка: число | строка | знак адресной азбуки — ровно один знак |
«Значение знака 64» | код: число | число | значение знака либо шестёрка, либо честный отказ минус один |
«Это знак 64» | знак: строка | признак | знак азбуки — ровно один из шестидесяти шести знаков обеих азбук |
«Первая шестёрка» | байт: число | число | первая шестёрка неотрицательна, пока байт конечен |
«Вторая шестёрка» | первый: число, второй: число | число | вторая шестёрка неотрицательна, пока байты конечны |
«Третья шестёрка» | второй: число, третий: число | число | третья шестёрка неотрицательна, пока байты конечны |
«Четвёртая шестёрка» | байт: число | число | четвёртая шестёрка неотрицательна, пока байт конечен |
«Тройка байтов» | первый: число, второй: число, третий: число | строка | тройка байтов даёт ровно четыре знака |
«Шаг кодирования» | ход: «Ход кодирования 64», байт: число | «Ход кодирования 64» | пока байтов меньше трёх, кодировка не растёт, а счёт растёт на один |
«Закрыть кодирование» | ход: «Ход кодирования 64» | строка | недобранная тройка добивается ровно до четырёх знаков, добранная не трогается |
«Закодировать байты» | байты: список числа | строка | длина кодировки кратна четырём |
«Сложить шестёрку» | готовые: список числа, сколько: число, набралось: число | «Ход раскодирования 64» | четвёртая шестёрка выкладывает ровно три байта и обнуляет копилку |
«Свести шестёрку» | ход: «Ход раскодирования 64», значение: число | «Ход раскодирования 64» | знак не из азбуки хода не меняет |
«Шаг раскодирования 64» | ход: «Ход раскодирования 64», знак: строка | «Ход раскодирования 64» | знак не из азбуки пропускается без следа |
«Закрыть раскодирование» | ход: «Ход раскодирования 64» | список числа | хвост из двух знаков даёт байт, из трёх — два, из нуля — ни одного |
«Раскодировать в байты» | код: строка | список числа | байтов не больше, чем знаков |
Wire
The shared half of a binary protocol: octets, network-order integers, zero-terminated strings, cutting a stream into pieces.
Import: использует «Wire».
Types: «Печать», «Набор байтов», «Разбор целого», «Разбор строки», «Разбор числа».
| function | takes | returns | what it does |
|---|---|---|---|
«Знак байта» | байт: число | строка | печатаемый байт даёт ровно один знак, всякий другой — ни одного |
«Байт печатается» | байт: число | признак | печатается только тот байт, у которого в таблице знак |
«Код знака байта» | байт: число | число | что положили байтом, то и достали кодом |
«Байтов в знаке» | знак: строка | число | ноль байтов весит пустой знак и только он, всякий другой — от одного до четырёх |
«Знак испорчен» | знак: строка | признак | порчей считается ровно то, что начинается знаком замены |
«Знаки текста» | текст: строка | список строки | знаков ровно столько, какова длина текста |
«Текст знаков» | знаки: список строки | строка | в склейке ровно столько знаков, сколько их было во всех кусках |
«Байтов в тексте» | текст: строка | число | байтов не меньше, чем знаков, и не больше, чем вчетверо |
«Есть порча» | знаки: список строки | признак | у пустого списка порчи нет, а на одном знаке порча — это порча самого знака |
«Коды нулевые» | знаки: список строки | признак | нулевые коды значат текст из одних нулевых знаков, по знаку на звено |
«Набрать байты» | знаки: список строки, сколько: число | «Набор байтов» | набранное весит ровно столько октетов, сколько просили, вместе с остатком даёт исходный поток, а отказ бывает только при непустом запросе |
«Дописать знак спереди» | знак: строка, набор: «Набор байтов» | «Набор байтов» | дописка исхода не меняет, удлиняет набранное ровно на один знак и остатка не трогает |
«Взять целое» | знаки: список строки, ширина: неотрицательное, набрано: число | «Разбор целого» | нулевая ширина берёт накопленное и входа не трогает, а испортиться целое может только при непустой ширине |
«Взять строку» | знаки: список строки | «Разбор строки» | взятая строка — начало входа, нуль съеден, а нуля не нашлось только там, где вход не начинается нулём |
«Дописать знак к строке» | знак: строка, исход: «Разбор строки» | «Разбор строки» | дописка исхода не меняет, удлиняет текст ровно на длину знака и остатка не трогает |
«Текст до нуля» | знаки: список строки | строка | текст до нуля — начало потока, и до первого нуля он доходит целиком |
«Хвост после нуля» | знаки: список строки, запас: неотрицательное | список строки | хвост после нуля короче входа, а начальный нуль снимает ровно один знак |
«Последние» | знаки: список строки, сколько: число | список строки | последних берётся ровно столько, сколько просили, а если столько не набралось — весь список |
«Без первых» | знаки: список строки, сколько: число | список строки | снимается ровно столько первых, сколько просили, а больше, чем есть, не снимается |
«Четыре знака» | значение: число | «Печать» | напечатано ровно четыре знака, и печатается ровно то число, у которого печатаемы все четыре октета |
«Четыре октета печатаются» | значение: число | признак | отрицательное не печатается |
«Четыре октета» | значение: число | строка | печатаемое число читается из своих четырёх октетов обратно тем же числом |
«Два октета» | значение: число | строка | число, умещающееся в два печатаемых октета, читается из них обратно тем же числом |
«Строка с нулём» | текст: строка | строка | строка с нулём — тот же текст и ровно один лишний знак в один байт |
«Число из целого» | целое: «Разбор целого» | число | взятое целое отдаётся своим значением, испорченное — нулём |
«Текст печати» | печать: «Печать» | строка | напечатанное отдаётся своим текстом, а непечатаемое — пустой строкой |
«Цифра провода» | знак: строка | число | знак-цифра даёт своё значение |
«Цифры числом» | знаки: список строки, набрано: число | число | пустой список отдаёт накопленное, цифра приписывается справа, а не цифра портит всё число |
«Целое из текста» | текст: строка | «Разбор числа» | пустой текст числом не считается |
«Число без знака» | знаки: список строки | «Разбор числа» | пусто и длиннее пятнадцати цифр числом не считается |
«Отрицать число» | исход: «Разбор числа» | «Разбор числа» | разобранное число меняет знак, а не число остаётся не числом |
Postgres
The PostgreSQL 3.0 protocol, pure half: building client messages and parsing server ones. No socket here.
Import: использует «Postgres».
Types: «Поле», «Беда базы», «Весть», «Разбор вести», «Разбор потока», «Значение».
| function | takes | returns | what it does |
|---|---|---|---|
«Кадр» | метка: строка, тело: строка | «Печать» | кадр — метка, четыре октета длины и тело, а названное непечатаемым число есть та самая длина |
«Пуск» | пользователь: строка, база: строка | «Печать» | пусковое сообщение — четыре октета длины и тело, и записанная длина есть весь его размер в байтах |
«Тело пуска» | пользователь: строка, база: строка | строка | тело пуска — версия протокола, две пары с нулями и завершающий нуль: двадцать один знак сверх обоих имён |
«Простой запрос» | запрос: строка | «Печать» | простой запрос едет буквой Q, а вместе с длиной и завершающим нулём весит на шесть байтов больше самого запроса |
«Начало SASL» | способ: строка, ответ: строка | «Печать» | первое сообщение SASL едет буквой p, а вместе с двумя длинами, именем способа и его нулём весит на десять байтов больше способа и ответа вместе |
«Ответ SASL» | ответ: строка | «Печать» | ответ SASL едет буквой p, а вместе с длиной весит на пять байтов больше самого ответа |
«Пароль открытым текстом» | пароль: строка | «Печать» | пароль едет малой буквой p, а вместе с длиной и завершающим нулём весит на шесть байтов больше самого пароля |
«Прощание» | — | «Печать» | прощание — буква X и записанная длина четыре, а всего пять байтов |
«Согласование» | — | «Печать» | согласование — буква S и записанная длина четыре, а всего пять байтов |
«Подготовка» | запрос: строка | «Печать» | подготовка едет буквой P с безымянным запросом и без объявленных типов: на девять байтов больше самого запроса |
«Привязка» | значения: список строки | «Печать» | привязка едет буквой B и весит на пять байтов больше своего тела, а непечатаемой бывает лишь от негодных значений или от негодной длины |
«Значения привязываются» | значения: список строки | признак | пустой список привязывается, а список от ста двадцати восьми значений — уже нет |
«Тело привязки» | значения: список строки | строка | тело привязки — два безымянных имени, ноль форматов, число значений и ноль форматов ответа: восемь знаков сверх самих значений |
«Значения параметров» | значения: список строки | строка | значения едут подряд, и каждое несёт впереди четыре октета своей длины |
«Значение с длиной впереди» | значение: строка | строка | перед значением стоят четыре октета его длины в байтах, и они читаются обратно тем же числом |
«Исполнение» | — | «Печать» | исполнение — буква E, безымянный портал, нулевой предел строк, и записанная длина сходится с размером |
«Дополнить запрос» | запрос: строка, надбавка: число, запас: неотрицательное | строка | дополнение только приписывает пробелы: запрос остаётся началом, а длина растёт не больше чем на запас |
«Разобрать весть» | знаки: список строки | «Разбор вести» | разобранная весть съедает из потока не меньше пяти знаков, а ждать велят лишь там, где знаков меньше, чем обещала длина |
«Разобрать весть по длине» | метка: строка, целое: «Разбор целого» | «Разбор вести» | испорченная длина и длина меньше четырёх дают порчу кадра с названной причиной, и никак иначе |
«Разобрать весть по телу» | метка: строка, набор: «Набор байтов» | «Разбор вести» | весть выходит только из целого тела без знака замены, нехватка байтов значит ждать, а знак поперёк границы — порчу |
«Разобрать тело» | метка: строка, тело: список строки | «Весть» | незнакомой буква названа своим именем и только тогда, когда она и вправду не из четырнадцати понятых |
«Разобрать тело дальше» | метка: строка, тело: список строки | «Весть» | здесь понимают восемь букв, и всякая другая выходит наружу своим именем |
«Разобрать вход» | целое: «Разбор целого» | «Весть» | нулём вход разрешён, тройкой просят пароль, десяткой предлагают SASL, одиннадцатой продолжают, двенадцатой кончают — и груз каждой из трёх приезжает целиком; всякий иной способ назван своим числом, а испорченное целое — минус единицей |
«Разобрать настройку» | исход: «Разбор строки» | «Весть» | имя настройки — это взятая строка, значение — текст до следующего нуля, а без нуля настройка безымянна и пуста |
«Разобрать поля» | целое: «Разбор целого», запас: неотрицательное | список «Поле» | полей выходит не больше, чем обещало их число, и не больше запаса, а испорченное число полей не даёт ни одного |
«Собрать поля» | знаки: список строки, сколько: число, запас: неотрицательное | список «Поле» | полей не больше, чем просили, и не больше запаса |
«Разобрать беду» | тело: список строки | «Беда базы» | метка S в начале тела становится важностью беды |
«Поле беды» | тело: список строки, метка: строка, запас: неотрицательное | строка | поле беды — текст до нуля сразу за искомой меткой |
«Разобрать поток» | знаки: список строки, запас: неотрицательное | «Разбор потока» | вестей выходит не больше запаса, остаток не длиннее входа, а оборван поток бывает только с названной причиной |
«Приписать весть» | весть: «Весть», поток: «Разбор потока» | «Разбор потока» | приписка удлиняет список вестей ровно на одну, исхода потока не меняет и ни остатка, ни причины не трогает |
«Ответ дочитан» | знаки: список строки | признак | проверка на шесть знаков здесь лишняя: её делает сама проверка на готовность |
«Это готовность» | знаки: список строки | признак | готовность — шесть знаков, из которых первые пять есть Z и длина пять; шестой не проверяется вовсе |
«Пароль спрошен» | знаки: список строки | признак | проверка на девять знаков здесь лишняя: её делает сама проверка на просьбу |
«Это просьба о пароле» | знаки: список строки | признак | просьба о пароле — ровно девять знаков R 00 00 00 08 00 00 00 03, и ни один не оставлен на волю |
«Есть отказ» | вести: список «Весть» | признак | у пустого списка отказа нет |
«Это отказ» | весть: «Весть» | признак | отказ узнаётся по варианту вести, и только по нему |
«Вход прошёл» | вести: список «Весть» | признак | у пустого списка разрешения нет |
«Это разрешение» | весть: «Весть» | признак | разрешение узнаётся по варианту вести, и только по нему |
«Строки ответа» | вести: список «Весть» | список строки | строк выходит ровно столько, сколько среди вестей строк данных |
«Досыпать строку» | весть: «Весть», собрано: список строки | список строки | строка данных досыпается в конец ровно одна, прочее проносит собранное нетронутым, и собранное всегда остаётся началом |
«Строка полей» | ячейки: список «Поле» | строка | поля склеены табуляциями: длина есть сумма длин полей плюс разделители |
«Текст поля» | ячейка: «Поле» | строка | текст поля — это записанный в поле текст |
«Итог дела» | вести: список «Весть» | строка | у пустого списка итога нет, а на одной вести итог — это её же досыпка к пустому |
«Досыпать метку» | весть: «Весть», собрано: строка | строка | метку берёт только весть о сделанном деле, прочее проносит собранное нетронутым |
«Текст отказа» | вести: список «Весть» | строка | текст отказа пуст ровно тогда, когда отказа среди вестей нет |
«Досыпать отказ» | весть: «Весть», собрано: строка | строка | текст берёт только весть об отказе, прочее проносит собранное нетронутым |
«Текст беды» | беда: «Беда базы» | строка | текст беды — важность, код и сообщение через два пробела, и начинается он с важности |
«Значение поля» | оид: число, текст: строка | «Значение» | логическая колонка истинна ровно на букве t |
«Текстовый тип» | оид: число | признак | текст — текстовый тип |
«Целое значение» | текст: строка, оид: число | «Значение» | пустой текст целым не становится и приезжает нетронутым |
«Вести потока» | поток: «Разбор потока» | список «Весть» | вестей выходит ровно столько, сколько поток успел разобрать — и у целого потока, и у оборванного |
«Причина обрыва» | поток: «Разбор потока» | строка | у целого потока причины нет, у оборванного она — та самая, что записана |
«Настройки потока» | вести: список «Весть» | список строки | пар выходит ровно столько, сколько среди вестей настроек |
«Досыпать настройку» | весть: «Весть», собрано: список строки | список строки | настройка досыпается в конец одной парой из имени, знака равенства и значения, прочее проносит собранное нетронутым |
Redis
The Redis protocol (RESP 2), pure half: building commands and parsing replies.
Import: использует «Redis».
Types: «Ответ Redis», «Разбор Redis», «Край Redis», «Поток Redis».
| function | takes | returns | what it does | |
|---|---|---|---|---|
«Край строки» | — | строка | край — два знака: тринадцатый и десятый коды | |
«Груз строкой» | текст: строка | строка | груз начинается с доллара, несёт сам текст, и длиннее его ровно на доллар, запись длины и два края | |
«Грузы» | части: список строки | строка | пустой список даёт пустую запись, а всякая часть весит не меньше пяти знаков | |
«Команда» | части: список строки | строка | команда начинается со звёздочки и числа частей, а длиной равна шапке вместе с грузами | |
«Отклик» | — | строка | отклик — команда из одной части, и часть эта PING | |
«Вход» | пароль: строка | строка | вход — команда из двух частей, в ней стоит слово AUTH и сам пароль | |
«Вход с именем» | имя: строка, пароль: строка | строка | вход с именем — команда из трёх частей, и в ней стоят оба довода | |
«Положить в Redis» | ключ: строка, значение: строка | строка | запись — команда из трёх частей, и в ней стоят ключ и значение | |
«Взять значение» | ключ: строка | строка | чтение — команда из двух частей, и в ней стоит ключ | |
«Убрать ключ» | ключ: строка | строка | удаление — команда из двух частей, и в ней стоит ключ | |
«Сколько ключей» | — | строка | счёт ключей — команда из одной части | |
«Выбрать базу» | номер: неотрицательное | строка | выбор базы — команда из двух частей, и номер в ней записан десятичной записью | |
«Проститься» | — | строка | прощание — команда из одной части | |
«Дописать знак к краю» | знак: строка, исход: «Край Redis» | «Край Redis» | дописка к краю исхода не меняет, удлиняет текст ровно на длину знака и остатка не трогает | |
«Взять край» | знаки: список строки | «Край Redis» | взятый текст — начало входа, а остаток короче входа ровно на этот текст и два знака края | |
«Край за возвратом» | хвост: список строки | «Край Redis» | край берётся только при переводе строки следом, и снимает он ровно один знак | |
«Ответ числом» | исход: «Разбор числа», дальше: список строки | «Разбор Redis» | разобранное целое становится счётом с тем же значением, а неразобранное — названной порчей | |
«Груз с краем» | текст: строка, край: «Край Redis» | «Разбор Redis» | край сразу за телом даёт груз с тем же текстом, край с лишними знаками — названную порчу, а отсутствие края — нехватку | |
«Груз по набору» | набор: «Набор байтов» | «Разбор Redis» | недобранные байты значат нехватку, а не порчу | |
«Ответ грузом» | исход: «Разбор числа», дальше: список строки | «Разбор Redis» | отрицательная длина даёт отсутствие значения, неразобранная — названную порчу | |
«Разобрать по метке» | метка: строка, край: «Край Redis» | «Разбор Redis» | плюс даёт слово, минус — беду, а без края разбирать нечего | |
«Разобрать простой ответ» | знаки: список строки | «Разбор Redis» | пустой поток значит нехватку, а набор внутри набора назван порчей | |
«Собрать части» | знаки: список строки, осталось: число, собрано: список «Ответ Redis», запас: неотрицательное | «Разбор Redis» | готовый набор несёт не меньше частей, чем уже было собрано | |
«Набор по числу» | исход: «Разбор числа», дальше: список строки, запас: неотрицательное | «Разбор Redis» | неразобранное число частей — названная порча, отрицательное — отсутствие набора | |
«Разобрать набор» | край: «Край Redis», запас: неотрицательное | «Разбор Redis» | без края набора нет — байты ещё едут | |
«Разобрать ответ» | знаки: список строки, запас: неотрицательное | «Разбор Redis» | пустой поток значит нехватку | |
«Разобрать поток Redis» | знаки: список строки, ответы: список «Ответ Redis», запас: неотрицательное | «Поток Redis» | разобранных ответов не меньше, чем было накоплено, а обрыв всегда назван причиной | |
«Текст простого ответа» | ответ: «Ответ Redis» | строка | слово и груз отдают свой текст, отказ помечен словом, отсутствие значения названо, а не подменено пустотой | |
«Тексты частей» | части: список «Ответ Redis» | строка | пустой набор даёт пустую запись | |
«Текст ответа» | ответ: «Ответ Redis» | строка | набор берётся в скобки и ровно на них длиннее своего содержимого, а всё прочее печатается как простой ответ | |
«Тексты ответов» | ответы: список «Ответ Redis» | строка | пустой список даёт пустую запись | |
«Это отказ Redis» | ответ: «Ответ Redis» | признак | отказом считается только беда | |
«Есть отказ Redis» | ответы: список «Ответ Redis» | признак | в пустом списке отказа нет |
Tree map
A string → string map as a search tree: O(log n) access.
Import: использует «Tree map».
Types: «Дерево».
| function | takes | returns | what it does |
|---|---|---|---|
«Строка раньше» | первая: строка, вторая: строка | признак | пустая раньше всякой непустой, а непустая не раньше пустой |
«Хеш строки» | текст: строка | число | хеш неотрицателен |
«Это дерево поиска» | дерево: «Дерево» | признак | пустое дерево — дерево поиска |
«Приоритет» | дерево: «Дерево» | число | у листа приоритета нет, а у узла он — записанный в узле |
«Уравновесить слева» | узел: «Дерево» | «Дерево» | уравновешивание слева не заводит и не хоронит узлов |
«Уравновесить справа» | узел: «Дерево» | «Дерево» | уравновешивание справа не заводит и не хоронит узлов |
«Положить в дерево» | дерево: «Дерево», ключ: строка, значение: строка | «Дерево» | положенный ключ в дереве есть |
«Найти в дереве» | дерево: «Дерево», искомый: строка, запасное: строка | строка | чего нет среди ключей, того поиск не выдумывает: отдаётся запасное |
«Есть ключ в дереве» | дерево: «Дерево», искомый: строка | признак | в дереве поиска ключ есть ровно тогда, когда он среди ключей |
«Размер дерева» | дерево: «Дерево» | число | размер неотрицателен |
«Глубина дерева» | дерево: «Дерево» | число | глубина ноль ровно у дерева без ключей |
«Глубже» | слева: число, справа: число | число | глубже не мельче каждой из половин |
«Ключи дерева» | дерево: «Дерево» | список строки | ключей ровно столько, сколько узлов |
«Дерево из ключей» | ключи: список строки | «Дерево» | из пустого списка — пустое дерево, из непустого — непустое |
String lists
Lists of strings: first, last, tail, join, access by index, common prefix.
Import: использует «String lists».
| function | takes | returns | what it does |
|---|---|---|---|
«Первая строка» | части: список строки | строка | первая строка есть строка номер один |
«Последняя строка» | части: список строки | строка | последняя — это строка с номером, равным длине списка |
«Хвост строк» | части: список строки | список строки | хвост короче ровно на одну, и первая с хвостом склеиваются в исходное |
«Строка по номеру» | части: список строки, номер: неотрицательное, запасная: строка | строка | номер в списке даёт элемент этого номера |
«Номер строки» | части: список строки, искомая: строка | число | ноль ровно тогда, когда строки нет, а ненулевой номер показывает на неё |
«Дописать строку» | части: список строки, новая: строка | список строки | дописывание удлиняет список ровно на один |
«Склеить» | части: список строки | строка | склейка начинается первой частью, а одна часть склеивается сама в себя |
«Хвост через» | части: список строки, разделитель: строка | строка | это ровно склейка того хвоста, который отдаёт функция хвоста |
«Непустые» | части: список строки | список строки | склейка непустых та же, что склейка всех |
«Общее начало двух» | первая: строка, вторая: строка | строка | общее начало начинает обе строки и дальше них не тянется |
«Общее начало» | части: список строки | строка | начинает первую и последнюю часть, не длиннее их общего начала, а на одной и на двух частях совпадает с ним точно |
«Слова» | текст: строка | список строки | склейка слов та же, что склейка кусков |
Number tree
An ordered tree of numbers: insert, search, sort by traversal.
Import: использует «Number tree».
Types: «Дерево чисел».
| function | takes | returns | what it does |
|---|---|---|---|
«Добавить число» | дерево: «Дерево чисел», число: число | «Дерево чисел» | добавленное число в дереве находится |
«Дерево из чисел» | элементы: список числа | «Дерево чисел» | в дереве ровно столько чисел, сколько в списке |
«Есть число» | дерево: «Дерево чисел», число: число | признак | поиск не выдумывает чисел, а в дереве из одной развилки и не промахивается |
«Обход по порядку» | дерево: «Дерево чисел» | список числа | обход не короче высоты дерева |
«Сортировать деревом» | элементы: список числа | список числа | сортировка деревом не теряет и не добавляет чисел |
«Высота» | дерево: «Дерево чисел» | число | высота дерева неотрицательна |
HMAC
HMAC-SHA256 signatures — RFC 2104 and RFC 4231.
Import: использует «HMAC».
Types: «Ход начала», «Ход слияния».
| function | takes | returns | what it does |
|---|---|---|---|
«Байты слова» | слово: число | список числа | слово занимает ровно четыре байта |
«Байты шестнадцатеричным» | байты: список числа | строка | на каждый байт ровно два знака |
«Байты свода» | свод: «Свод sha256» | список числа | — |
«Шаг начала» | ход: «Ход начала», байт: число | «Ход начала» | пока просят — берём |
«Начало списка» | байты: список числа, сколько: число | список числа | взято меньшее из заказанного и наличного |
«Байт или ноль» | байты: список числа, номер: число | число | первый |
«Шаг слияния» | ход: «Ход слияния», байт: число | «Ход слияния» | первый разряд сливается со вторым списком |
«Исключающее или списков» | первый: список числа, второй: список числа | список числа | слияние длиной в первый список |
«Ключ блока» | ключ: список числа | список числа | ключ приведён ровно к блоку хеша |
«Набивка ключа» | блок: список числа, набивка: число | список числа | набивка не меняет длину |
«Подпись байтами» | ключ: список числа, сообщение: список числа | список числа | подпись — ровно тридцать два байта |
«Подпись шестнадцатеричным» | ключ: список числа, сообщение: список числа | строка | подпись печатается ровно шестьюдесятью четырьмя знаками |
SCRAM
Client-side SCRAM-SHA-256 login — RFC 5802 and RFC 7677.
Import: использует «SCRAM».
| function | takes | returns | what it does |
|---|---|---|---|
«Октеты ASCII» | текст: строка | список числа | октетов ровно столько, сколько знаков |
«Строка только из ASCII» | текст: строка | признак | строка, начинающаяся знаком за пределом ASCII, признаётся негодной |
«Поле сообщения» | сообщение: строка, имя: строка | строка | соль |
«Цифра знака» | знак: строка | число | ноль |
«Число из текста» | текст: строка | число | пустая запись даёт ноль |
«Соль вызова» | вызов: строка | список числа | соль раскодируется из основания 64 |
«Витков вызова» | вызов: строка | число | витки берутся числом, а не строкой |
«Одноразовое вызова» | вызов: строка | строка | одноразовое сервера начинается одноразовым клиента |
«Первое клиента без заголовка» | пользователь: строка, одноразовое: строка | строка | первое сообщение начинается именем и несёт одноразовое целиком |
«Первое клиента» | пользователь: строка, одноразовое: строка | строка | заголовок GS2 стоит впереди, и это ровно три знака |
«Последнее без подписи» | вызов: строка | строка | последнее сообщение возвращает серверу его же одноразовое и заголовок GS2 |
«Сообщение подписи» | пользователь: строка, одноразовое: строка, вызов: строка | строка | в сообщение подписи входит вызов сервера целиком |
«Солёный пароль» | пароль: список числа, вызов: строка | список числа | солёный пароль — ровно тридцать два байта |
«Ключ клиента» | солёный: список числа | список числа | ключ клиента — ровно тридцать два байта |
«Серверный ключ» | солёный: список числа | список числа | серверный ключ — ровно тридцать два байта |
«Хранимый ключ» | клиентский: список числа | список числа | — |
«Доказательство клиента» | пароль: список числа, пользователь: строка, одноразовое: строка, вызов: строка | список числа | доказательство — ровно тридцать два байта |
«Последнее клиента» | пароль: список числа, пользователь: строка, одноразовое: строка, вызов: строка | строка | последнее сообщение начинается тем же, что и без подписи |
«Подпись сервера» | пароль: список числа, пользователь: строка, одноразовое: строка, вызов: строка | строка | подпись сервера — поле v и ровно сорок четыре знака основания 64 |
«Проверка сервера сошлась» | пароль: список числа, пользователь: строка, одноразовое: строка, вызов: строка, проверка: строка | признак | пустая проверка не сходится никогда |
SHA-1
SHA-1, HMAC-SHA1 and PBKDF2-HMAC-SHA1. The hash is obsolete: take it only where somebody else’s protocol demands exactly it.
Import: использует «SHA-1».
Types: «Свод SHA-1», «Ход блока SHA-1», «Ход хеша SHA-1», «Ход вывода SHA-1».
| function | takes | returns | what it does | |
|---|---|---|---|---|
«Начальный свод SHA-1» | — | «Свод SHA-1» | 67452301 efcdab89 98badcfe 10325476 c3d2e1f0 | |
«Номера раундов SHA-1» | — | список числа | раундов ровно восемьдесят | |
«Постоянная раунда SHA-1» | номер: число | число | постоянная — слово | |
«Смесь раунда SHA-1» | номер: число, второе: число, третье: число, четвёртое: число | число | смесь — слово | |
«Следующее слово SHA-1» | расписание: «Расписание» | число | следующее слово — слово сверху | |
«Шаг раунда SHA-1» | ход: «Ход блока SHA-1», номер: число | «Ход блока SHA-1» | — | |
«Сложить своды SHA-1» | первый: «Свод SHA-1», второй: «Свод SHA-1» | «Свод SHA-1» | — | |
«Сжать блок SHA-1» | свод: «Свод SHA-1», блок: список числа | «Свод SHA-1» | — | |
«Шаг байта SHA-1» | ход: «Ход хеша SHA-1», байт: число | «Ход хеша SHA-1» | — | |
«Свод байтов SHA-1» | байты: список числа | «Свод SHA-1» | — | |
«Байты свода SHA-1» | свод: «Свод SHA-1» | список числа | — | |
«Хеш байтов SHA-1» | байты: список числа | строка | хеш SHA-1 — ровно сорок знаков | |
«Ключ блока SHA-1» | ключ: список числа | список числа | ключ SHA-1 приведён ровно к блоку хеша | |
«Подпись байтами SHA-1» | ключ: список числа, сообщение: список числа | список числа | подпись SHA-1 — ровно двадцать байтов | |
«Подпись SHA-1 шестнадцатеричным» | ключ: список числа, сообщение: список числа | строка | подпись печатается ровно сорока знаками | |
«Дописать номер SHA-1» | меньшие: список числа, байтов: число | список числа | граница куска — номер дописывается | |
«Номера кусков SHA-1» | байтов: неотрицательное | список числа | кусков SHA-1 хватает на заказанную длину | |
«Шаг витка SHA-1» | пароль: список числа, ход: «Ход вывода SHA-1» | «Ход вывода SHA-1» | — | |
«Витки вывода SHA-1» | пароль: список числа, ход: «Ход вывода SHA-1», осталось: число | «Ход вывода SHA-1» | — | |
«Итог витков SHA-1» | ход: «Ход вывода SHA-1» | список числа | — | |
«Кусок вывода SHA-1» | пароль: список числа, соль: список числа, повторов: число, номер: число | список числа | кусок — ровно двадцать байтов | |
«Вывод ключа SHA-1» | пароль: список числа, соль: список числа, повторов: число, байтов: неотрицательное | список числа | ключ SHA-1 ровно заказанной длины |
SHA-256
The SHA-256 hash — FIPS 180-4.
Import: использует «SHA-256».
Types: «Свод sha256», «Расписание», «Ход блока», «Сбор слов», «Ход хеша».
| function | takes | returns | what it does |
|---|---|---|---|
«Веса слова» | — | список числа | разрядов ровно тридцать два |
«Бит» | слово: число, вес: число | число | младший бит целого слова — остаток от двойки |
«Четвёрка» | слово: число, вес: число | число | младшая четвёрка целого слова — остаток от шестнадцати |
«Свести к слову» | х: число | число | слово неотрицательно, пока это число |
«Свести к байту» | байт: число | число | байт неотрицателен, пока это число |
«Это байты» | байты: список числа | признак | у пустого списка байтовость истинна |
«Исключающее или трёх» | первое: число, второе: число, третье: число | число | результат — слово снизу, пока это число |
«Выбор» | условие: число, единичное: число, нулевое: число | число | выбор — слово снизу, пока это число |
«Большинство» | первое: число, второе: число, третье: число | число | большинство — слово снизу, пока это число |
«Поворот вправо» | слово: число, степень: число | число | поворот — слово снизу, пока это число |
«Сдвиг вправо» | слово: число, степень: число | число | сдвиг — слово снизу, пока это число |
«Большая сигма ноль» | слово: число | число | большая сигма ноль — слово сверху, пока это число |
«Большая сигма один» | слово: число | число | большая сигма один — слово сверху, пока это число |
«Малая сигма ноль» | слово: число | число | малая сигма ноль — слово сверху, пока это число |
«Малая сигма один» | слово: число | число | малая сигма один — слово сверху, пока это число |
«Начальный свод» | — | «Свод sha256» | 6a09e667 bb67ae85 3c6ef372 a54ff53a 510e527f 9b05688c 1f83d9ab 5be0cd19 |
«Постоянные раунда» | — | список числа | постоянных ровно шестьдесят четыре |
«Пустое расписание» | — | «Расписание» | у пустого расписания все шестнадцать слов — нули |
«Сдвинуть расписание» | расписание: «Расписание», слово: число | «Расписание» | сдвиг съезжает на одно поле, а новое слово встаёт последним |
«Следующее слово» | расписание: «Расписание» | число | следующее слово — слово сверху, пока это число |
«Шаг сбора слов» | сбор: «Сбор слов», байт: число | «Сбор слов» | четвёртый байт замыкает слово: копилка обнуляется, а слово встаёт последним в расписании |
«Расписание блока» | блок: список числа | «Расписание» | четыре байта складываются в одно слово старшим байтом вперёд и встают последним полем |
«Шаг раунда» | ход: «Ход блока», постоянная: число | «Ход блока» | первый раунд блока abc из fips |
«Сложить своды» | первый: «Свод sha256», второй: «Свод sha256» | «Свод sha256» | — |
«Сжать блок» | свод: «Свод sha256», блок: список числа | «Свод sha256» | единственный блок сообщения abc — это и есть весь хеш abc |
«Нули» | сколько: неотрицательное | список числа | нулей не бывает меньше нуля |
«Байт разряда» | число: число, степень: число | число | младший байт целого числа — остаток от двухсот пятидесяти шести |
«Байты длины» | битов: число | список числа | длина занимает ровно восемь байтов |
«Дополнить сообщение» | байты: список числа | список числа | дополненное сообщение делится на блоки нацело |
«Шаг байта» | ход: «Ход хеша», байт: число | «Ход хеша» | шестьдесят четвёртый байт закрывает блок: буфер пустеет, счёт обнуляется |
«Свод байтов» | байты: список числа | «Свод sha256» | пустое сообщение |
«Азбука 16» | — | строка | в азбуке шестнадцать знаков |
«Цифра 16» | н: число | строка | цифра — ровно один знак |
«Слово шестнадцатеричным» | слово: число | строка | слово печатается ровно восемью знаками |
«Свод шестнадцатеричным» | свод: «Свод sha256» | строка | хеш печатается ровно шестьюдесятью четырьмя знаками |
«Хеш байтов» | байты: список числа | строка | хеш — ровно шестьдесят четыре знака |
UTF-8
Text into bytes and bytes back into code points — UTF-8, RFC 3629.
Import: использует «UTF-8».
Types: «Ход разбора utf8».
| function | takes | returns | what it does | |
|---|---|---|---|---|
«Одинокий суррогат» | код: число | признак | блок суррогатов — ровно 2048 точек подряд, считая от D800 | |
«Байты кодовой точки» | код: число | список числа | байтов у точки хотя бы один | |
«Байтов в точке» | код: число | число | байтов в точке хотя бы один | |
«Досыпать байты» | готовые: список числа, добавка: список числа | список числа | досыпка складывает длины | |
«Кодовые точки текста» | текст: строка | список числа | точек ровно столько, сколько символов | |
«Байты текста» | текст: строка | список числа | байтов не меньше, чем символов | |
«Длина в байтах» | текст: строка | число | длина в байтах не меньше длины в символах | |
«Текст без одиноких суррогатов» | текст: строка | признак | на тексте из одного знака ответ — это ответ про одинокий суррогат, взятый наоборот | |
«Начало разбора utf8» | — | «Ход разбора utf8» | начальный ход пуст: ни точек, ни недобранных байтов, ни замещений | |
«Начать байт» | точки: список числа, замещений: число, байт: число | «Ход разбора utf8» | точек не убыло при начале байта | |
«Шаг разбора utf8» | ход: «Ход разбора utf8», байт: число | «Ход разбора utf8» | шаг не теряет точек | |
«Закрыть разбор utf8» | ход: «Ход разбора utf8» | список числа | точек стало столько же ровно тогда, когда хвост цел | |
«Кодовые точки из байтов» | байты: список числа | список числа | точек не больше, чем байтов | |
«Байты годны как UTF-8» | байты: список числа | признак | пустое годно | |
«Круговой ход держится» | текст: строка | признак | круговой ход держится ровно там, где одиноких суррогатов нет | |
«Списки точек равны» | первый: список числа, второй: список числа | признак | равные списки одной длины и с одной головой |
Next
- Language reference — how the language itself is written
- Operations — a task → what solves it