РМв1.в

////
// Визначення для створення розширень Мавки.
//
// Приклад:
//
// взяти визначення РМв1;
// зовнішня дія завантажити_РМв1(Р: адреса<РМв1::Розширення>): РМв1::Результат {
//   РМв1::надрукувати_ю8(Р, ю8сі"Вітання з розширення!");
//   вернути РМв1::успіх(Р, пусто);
// }
////

////
// Автор це Богданович Давид Когут Прихожденко та Організація М та Організація Організацій
////

// Не рекомендується напряму отримувати властивості обʼєктів, а натомість використовувати публічні дії нижче.
секція РМв1 {
  // версія цього файлу визначень
  синонім МАЖОР = 1;
  синонім МІНОР = 0;
  синонім ПАТЧ = 0;

  структура Назва;
  структура Обʼєкт;
  структура Розширення;
  структура ІменованіАргументи;

  структура МісцезнаходженняПадіння {
    шлях_до_файлу: ю8;
    рядок: позитивне;
  }

  структура ЕлементІсторіїПадіння {
    шлях_до_файлу: ю8;
    рядок: позитивне;
    назва_дії: адреса<Назва>;
  }

  структура Падіння {
    місцезнаходження: адреса<МісцезнаходженняПадіння>;
    розмір_історії: позитивне;
    історія: памʼять<ЕлементІсторіїПадіння>;
  }

  структура Результат {
    падіння: адреса<Падіння>;
    значення: адреса<Обʼєкт>;
  }

  структура ЕлементСловника {
    ключ: адреса<Обʼєкт>;
    значення: адреса<Обʼєкт>;
  }

  синонім НативнаДія = (обʼєкт_нативної_дії: адреса<Обʼєкт>, Р: адреса<Розширення>, обʼєкт_я: адреса<Обʼєкт>, кількість_аргументів: позитивне, аргументи: памʼять<адреса<Обʼєкт>>, іменовані_аргументи: адреса<ІменованіАргументи>, дані: адреса) -> Результат;
  синонім ВідкликПередЗвільненнямОбʼєктаНативноїДії = (обʼєкт_нативної_дії: адреса<Обʼєкт>, Р: адреса<Розширення>, дані: адреса) -> ніщо;

  структура Розширення {
    мажор: позитивне;  // версія переданого розширення з мавки
    мінор: позитивне;
    патч: позитивне;
    дані: адреса; // власні дані розширення
    В: адреса; // виконувач мавки
    виділити_падіння: (Р: адреса<Розширення>) -> адреса<Падіння>;
    звільнити_падіння: (Р: адреса<Розширення>, падіння: адреса<Падіння>) -> ніщо;
    обʼєкт_логічного_так: адреса<Обʼєкт>;
    обʼєкт_логічного_ні: адреса<Обʼєкт>;
    надрукувати_ю8: (Р: адреса<Розширення>, значення: ю8) -> ніщо;
    надрукувати_обʼєкт: (Р: адреса<Розширення>, обʼєкт: адреса<Обʼєкт>, глибина: позитивне) -> ніщо;
    взяти_файл_ю8: (Р: адреса<Розширення>, назва_модуля: адреса<Назва>, шлях_до_файлу: ю8) -> Результат;
    зберегти_обʼєкт: (Р: адреса<Розширення>, обʼєкт: адреса<Обʼєкт>) -> ніщо;
    видалити_збережений_обʼєкт: (Р: адреса<Розширення>) -> ніщо;
    назва_з_ю8: (Р: адреса<Розширення>, значення: ю8) -> адреса<Назва>;
    створити_нативну_дію: (Р: адреса<Розширення>, назва: адреса<Назва>, значення: НативнаДія, дані: адреса, відклик_перед_звільненням: ВідкликПередЗвільненнямОбʼєктаНативноїДії) -> адреса<Обʼєкт>;
    створити_число: (Р: адреса<Розширення>, значення: д64) -> адреса<Обʼєкт>;
    створити_текст_з_ю8: (Р: адреса<Розширення>, значення: ю8) -> адреса<Обʼєкт>;
    створити_юнікод_з_ю8: (Р: адреса<Розширення>, значення: ю8) -> адреса<Обʼєкт>;
    створити_модуль: (Р: адреса<Розширення>, назва: адреса<Назва>) -> адреса<Обʼєкт>;
    створити_список: (Р: адреса<Розширення>) -> адреса<Обʼєкт>;
    створити_словник: (Р: адреса<Розширення>) -> адреса<Обʼєкт>;
    створити_обʼєкт: (Р: адреса<Розширення>) -> адреса<Обʼєкт>;
    обʼєкт_виконати: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, обʼєкт_я: адреса<Обʼєкт>, кількість_аргументів: позитивне, аргументи: памʼять<адреса<Обʼєкт>>, іменовані_аргументи: адреса<ІменованіАргументи>) -> Результат;
    обʼєкт_отримати_властивість: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>) -> Результат;
    обʼєкт_змінити_властивість: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>, значення: адреса<Обʼєкт>) -> Результат;
    обʼєкт_видалити_властивість: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>) -> Результат;
    обʼєкт_виконати_властивість: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>, кількість_аргументів: позитивне, аргументи: памʼять<адреса<Обʼєкт>>, іменовані_аргументи: адреса<ІменованіАргументи>) -> Результат;
    обʼєкт_отримати_елемент: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, ключ: адреса<Обʼєкт>) -> Результат;
    обʼєкт_змінити_елемент: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, ключ: адреса<Обʼєкт>, значення: адреса<Обʼєкт>) -> Результат;
    обʼєкт_видалити_елемент: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, ключ: адреса<Обʼєкт>) -> Результат;
    обʼєкт_отримати_перебір: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> Результат;
    обʼєкт_додати: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_відняти: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_помножити: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_поділити: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_остача: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_неповна_частка: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_степінь: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_вліво: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_вправо_зі_заповненням: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_двійкове_і: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_двійкове_або: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_двійкове_виключне_або: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_двійкове_не: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> Результат;
    обʼєкт_більше: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_менше: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_рівно: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_містить: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_є: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>) -> Результат;
    обʼєкт_відʼємне: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> Результат;
    обʼєкт_числове: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> Результат;
    обʼєкт_заперечити: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> Результат;
    обʼєкт_збільшити: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> Результат;
    обʼєкт_зменшити: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> Результат;
    отримати_значення_числа: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> д64;
    виділити: (Р: адреса<Розширення>, розмір: позитивне) -> памʼять<п8>;
    обробити_падіння: (Р: адреса<Розширення>, падіння: адреса<Падіння>, значення: адреса<Обʼєкт>) -> ніщо;
    звільнити: (Р: адреса<Розширення>, значення: адреса) -> ніщо;
    перевірити_чи_обʼєкт_є_дією: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    перевірити_чи_обʼєкт_є_нативною_дією: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    перевірити_чи_обʼєкт_є_числом: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    перевірити_чи_обʼєкт_є_текстом: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    перевірити_чи_обʼєкт_є_юнікодом: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    перевірити_чи_обʼєкт_є_модулем: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    перевірити_чи_обʼєкт_є_списком: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    перевірити_чи_обʼєкт_є_словником: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    перевірити_чи_обʼєкт_є_логічним: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    перевірити_чи_обʼєкт_є_байтами: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    отримати_копію_даних_тексту: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<текст>) -> логічне;
    отримати_дані_тексту: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<текст>) -> логічне;
    отримати_копію_даних_юнікоду: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: невідома_адреса) -> логічне;
    отримати_дані_юнікоду: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: невідома_адреса) -> логічне;
    отримати_копію_даних_юнікоду_як_ю8: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<ю8>) -> логічне;
    отримати_копію_даних_байтів: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>) -> позитивне;
    отримати_дані_байтів: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>) -> позитивне;
    створити_байти: (Р: адреса<Розширення>, розмір: позитивне) -> адреса<Обʼєкт>;
    записати_в_байти: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, дані: памʼять<п8>, розмір: позитивне, зсув: позитивне) -> ніщо;
    отримати_елементи_словника: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<ЕлементСловника>>) -> позитивне;
    перевиділити: (Р: адреса<Розширення>, значення: памʼять<п8>, новий_розмір: позитивне) -> памʼять<п8>;
    знайти_іменований_аргумент: (Р: адреса<Розширення>, іменовані_аргументи: адреса<ІменованіАргументи>, назва: адреса<Назва>, вихід: адреса<адреса<Обʼєкт>>) -> логічне;
    записати_іменований_аргумент: (Р: адреса<Розширення>, іменовані_аргументи: адреса<ІменованіАргументи>, назва: адреса<Назва>, значення: адреса<Обʼєкт>) -> ніщо;
    виділити_іменовані_аргументи: (Р: адреса<Розширення>) -> адреса<ІменованіАргументи>;
    звільнити_іменовані_аргументи: (Р: адреса<Розширення>, іменовані_аргументи: адреса<ІменованіАргументи>) -> ніщо;
    створити_адресу: (Р: адреса<Розширення>, значення: адреса) -> адреса<Обʼєкт>;
    отримати_значення_адреси: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> адреса;
    перевірити_чи_обʼєкт_є_адресою: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>) -> логічне;
    отримати_елементи_списку: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<адреса<Обʼєкт>>>) -> позитивне;
    отримати_копію_даних_юнікоду_як_ю8сі: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>) -> позитивне;
    отримати_копію_даних_тексту_як_ю8сі: (обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>) -> позитивне;
    створити_юнікод_з_ю8сі: (Р: адреса<Розширення>, значення: памʼять<п8>) -> адреса<Обʼєкт>;
  }
}

// Публічні дії для створення розширення.
секція РМв1 {
  дія виділити_падіння(Р: адреса<Розширення>): адреса<Падіння>;
  дія звільнити_падіння(Р: адреса<Розширення>, падіння: адреса<Падіння>);

  // створює успішний результат
  дія успіх(Р: адреса<Розширення>, значення: адреса<Обʼєкт>): Результат;

  // створює результат падіння (місцезнаходження падіння визначається машиною автоматично)
  дія падіння(Р: адреса<Розширення>, значення: адреса<Обʼєкт>): Результат;

  // дозволяє запити користувацькі дані в розширення
  дія записати_дані_розширення(Р: адреса<Розширення>, дані: адреса);

  // дозволяє отримати користувацькі дані з розширення
  дія отримати_дані_розширення(Р: адреса<Розширення>): адреса;

  // записує в стандартний вивід значення юнікоду (UTF-8)
  дія надрукувати_ю8(Р: адреса<Розширення>, значення: ю8);

  // записує в стандартний вивід обʼєкт
  дія надрукувати_обʼєкт(Р: адреса<Розширення>, обʼєкт: адреса<Обʼєкт>, глибина: позитивне);

  // дозволяє взяти файл модуля Мавки
  дія взяти_файл_ю8(Р: адреса<Розширення>, назва_модуля: адреса<Назва>, шлях_до_файлу: ю8): Результат;

  // ця дія використовується щоб забезпечити недоторканість обʼєкта утилізатором
  дія зберегти_обʼєкт(Р: адреса<Розширення>, обʼєкт: адреса<Обʼєкт>);

  // видаляє останній збережий обʼєкт дією вище
  дія видалити_збережений_обʼєкт(Р: адреса<Розширення>);

  // дозволяє отримати назву з юнікоду (UTF-8)
  дія назва_з_ю8(Р: адреса<Розширення>, значення: ю8): адреса<Назва>;

  // створює обʼєкт нативної дії
  дія створити_нативну_дію(Р: адреса<Розширення>, назва: адреса<Назва>, значення: НативнаДія, дані: адреса, відклик_перед_звільненням: ВідкликПередЗвільненнямОбʼєктаНативноїДії): адреса<Обʼєкт>;

  // створює обʼєкт числа
  дія створити_число(Р: адреса<Розширення>, значення: д64): адреса<Обʼєкт>;

  // створює обʼєкт тексту з юнікоду (UTF-8)
  дія створити_текст_з_ю8(Р: адреса<Розширення>, значення: ю8): адреса<Обʼєкт>;

  // створює обʼєкт юнікоду з юнікоду (UTF-8)
  дія створити_юнікод_з_ю8(Р: адреса<Розширення>, значення: ю8): адреса<Обʼєкт>;

  // створює обʼєкт модуля
  дія створити_модуль(Р: адреса<Розширення>, назва: адреса<Назва>): адреса<Обʼєкт>;

  // створює обʼєкт списку
  дія створити_список(Р: адреса<Розширення>): адреса<Обʼєкт>;

  // створює обʼєкт словника
  дія створити_словник(Р: адреса<Розширення>): адреса<Обʼєкт>;

  // створює простий обʼєкт
  дія створити_обʼєкт(Р: адреса<Розширення>): адреса<Обʼєкт>;

  // виконує обʼєкт
  дія обʼєкт_виконати(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, обʼєкт_я: адреса<Обʼєкт>, кількість_аргументів: позитивне, аргументи: памʼять<адреса<Обʼєкт>>, іменовані_аргументи: адреса<ІменованіАргументи>): Результат;

  // отримує властивість обʼєкта
  дія обʼєкт_отримати_властивість(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>): Результат;

  // змінює властивість обʼєкта
  дія обʼєкт_змінити_властивість(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>, значення: адреса<Обʼєкт>): Результат;

  // видаляє властивість обʼєкта
  дія обʼєкт_видалити_властивість(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>): Результат;

  // виконує властивість обʼєкта
  дія обʼєкт_виконати_властивість(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>, кількість_аргументів: позитивне, аргументи: памʼять<адреса<Обʼєкт>>, іменовані_аргументи: адреса<ІменованіАргументи>): Результат;

  // отримує елемент обʼєкта
  дія обʼєкт_отримати_елемент(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, ключ: адреса<Обʼєкт>): Результат;

  // змінює елемент обʼєкта
  дія обʼєкт_змінити_елемент(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, ключ: адреса<Обʼєкт>, значення: адреса<Обʼєкт>): Результат;

  // видаляє елемент обʼєкта
  дія обʼєкт_видалити_елемент(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, ключ: адреса<Обʼєкт>): Результат;

  // отримує перебір обʼєкта
  дія обʼєкт_отримати_перебір(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат;

  // додає два обʼєкта
  дія обʼєкт_додати(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // віднімає два обʼєкта
  дія обʼєкт_відняти(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // множить два обʼєкта
  дія обʼєкт_помножити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // ділить два обʼєкта
  дія обʼєкт_поділити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // отримує остачу від ділення двох обʼєктів
  дія обʼєкт_остача(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // отримує неповну частку від ділення двох обʼєктів
  дія обʼєкт_неповна_частка(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // підносить обʼєкт до степеня
  дія обʼєкт_степінь(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // зсуває обʼєкт вліво
  дія обʼєкт_вліво(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // зсуває обʼєкт вправо з заповненням
  дія обʼєкт_вправо_зі_заповненням(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // виконує двійкове І
  дія обʼєкт_двійкове_і(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // виконує двійкове АБО
  дія обʼєкт_двійкове_або(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // виконує двійкове виключне АБО
  дія обʼєкт_двійкове_виключне_або(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // виконує двійкове НЕ
  дія обʼєкт_двійкове_не(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат;

  // перевіряє чи обʼєкт більше іншого обʼєкта
  дія обʼєкт_більше(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // перевіряє чи обʼєкт менше іншого обʼєкта
  дія обʼєкт_менше(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // перевіряє чи обʼєкт рівний іншому обʼєкту
  дія обʼєкт_рівно(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // перевіряє чи обʼєкт містить інший обʼєкт
  дія обʼєкт_містить(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // перевіряє чи обʼєкт є певної структури
  дія обʼєкт_є(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат;

  // негація
  дія обʼєкт_відʼємне(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат;

  // перетворює обʼєкт в число
  дія обʼєкт_числове(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат;

  // заперечення
  дія обʼєкт_заперечити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат;

  // збільшує обʼєкт
  дія обʼєкт_збільшити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат;

  // зменшує обʼєкт
  дія обʼєкт_зменшити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат;

  // отримує значення числа з обʼєкта
  // попередньо необхідно впевнитись, що обʼєкт є числом
  дія отримати_значення_числа(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): д64;

  // виділяє памʼять
  дія виділити<Т>(Р: адреса<Розширення>): адреса<Т>;

  // виділяє памʼять
  дія виділити<Т>(Р: адреса<Розширення>, кількість: позитивне): памʼять<Т>;

  // обробляє падіння, яке неможливо вернути
  дія обробити_падіння(Р: адреса<Розширення>, падіння: адреса<Падіння>, значення: адреса<Обʼєкт>);

  // звільняє памʼять
  дія звільнити(Р: адреса<Розширення>, значення: адреса);

  // перевіряє чи обʼєкт є дією
  дія перевірити_чи_обʼєкт_є_дією(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє чи обʼєкт є нативною дією
  дія перевірити_чи_обʼєкт_є_нативною_дією(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє чи обʼєкт є числом
  дія перевірити_чи_обʼєкт_є_числом(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє чи обʼєкт є текстом
  дія перевірити_чи_обʼєкт_є_текстом(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє чи обʼєкт є юнікодом
  дія перевірити_чи_обʼєкт_є_юнікодом(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє чи обʼєкт є модулем
  дія перевірити_чи_обʼєкт_є_модулем(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє чи обʼєкт є списком
  дія перевірити_чи_обʼєкт_є_списком(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє чи обʼєкт є словником
  дія перевірити_чи_обʼєкт_є_словником(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє чи обʼєкт є логічним
  дія перевірити_чи_обʼєкт_є_логічним(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє чи обʼєкт є байтами
  дія перевірити_чи_обʼєкт_є_байтами(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // перевіряє копію даних тексту
  дія отримати_копію_даних_тексту(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<текст>): логічне;

  // отримує дані тексту
  дія отримати_дані_тексту(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<текст>): логічне;

  // отримує копію даних тексту як ю8
  дія отримати_копію_даних_юнікоду(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: невідома_адреса): логічне;

  // отримує дані юнікоду
  дія отримати_дані_юнікоду(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: невідома_адреса): логічне;

  // отримує копію даних юнікоду як ю8
  дія отримати_копію_даних_юнікоду_як_ю8(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<ю8>): логічне;

  // отримує копію даних байтів
  дія отримати_копію_даних_байтів(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>): позитивне;

  // отримує дані байтів
  дія отримати_дані_байтів(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>): позитивне;

  // створює обʼєкт байтів
  дія створити_байти(Р: адреса<Розширення>, розмір: позитивне): адреса<Обʼєкт>;

  // копіює дані в обʼєкт байтів
  дія записати_в_байти(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, дані: памʼять<п8>, розмір: позитивне, зсув: позитивне);

  // отримує копію елементів словника
  дія отримати_елементи_словника(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<ЕлементСловника>>): позитивне;

  // перевиділяє памʼять
  дія перевиділити<Т>(Р: адреса<Розширення>, значення: памʼять<Т>, нова_кількість: позитивне): памʼять<Т>;

  // отримує іменований аргумент, вертає "ні" якщо аргументу немає
  дія знайти_іменований_аргумент(Р: адреса<Розширення>, іменовані_аргументи: адреса<ІменованіАргументи>, назва: адреса<Назва>, вихід: адреса<адреса<Обʼєкт>>): логічне;

  // записує іменований аргумент
  дія записати_іменований_аргумент(Р: адреса<Розширення>, іменовані_аргументи: адреса<ІменованіАргументи>, назва: адреса<Назва>, значення: адреса<Обʼєкт>);

  // виділяє іменовані аргументи
  дія виділити_іменовані_аргументи(Р: адреса<Розширення>): адреса<ІменованіАргументи>;

  // звільняє іменовані аргументи
  дія звільнити_іменовані_аргументи(Р: адреса<Розширення>, іменовані_аргументи: адреса<ІменованіАргументи>);

  // створює обʼєкт адреси
  дія створити_адресу(Р: адреса<Розширення>, значення: адреса): адреса<Обʼєкт>;

  // отримує адресу з обʼєкта адреси
  дія отримати_значення_адреси(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): адреса;

  // перевіряє чи обʼєкт є адресою
  дія перевірити_чи_обʼєкт_є_адресою(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне;

  // отримує копію елементів списку
  дія отримати_елементи_списку(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<адреса<Обʼєкт>>>): позитивне;

  // отримує копію даних тексту як ю8сі
  дія отримати_копію_даних_тексту_як_ю8сі(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>): позитивне;

  // отримує копію даних юнікоду як ю8сі
  дія отримати_копію_даних_юнікоду_як_ю8сі(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>): позитивне;

  // створює обʼєкт юнікоду з ю8сі (UTF-8)
  дія створити_юнікод_з_ю8сі(Р: адреса<Розширення>, значення: памʼять<п8>): адреса<Обʼєкт>;
}

секція РМв1 {
  дія виділити_падіння(Р: адреса<Розширення>): адреса<Падіння> {
    вернути Р.виділити_падіння(Р);
  }

  дія звільнити_падіння(Р: адреса<Розширення>, падіння: адреса<Падіння>) {
    Р.звільнити_падіння(Р, падіння);
  }

  дія успіх(Р: адреса<Розширення>, значення: адреса<Обʼєкт>): Результат {
    вернути Результат {
      падіння = пусто,
      значення = значення
    };
  }

  дія падіння(Р: адреса<Розширення>, значення: адреса<Обʼєкт>): Результат {
    вернути Результат {
      падіння = виділити_падіння(Р),
      значення = значення
    };
  }

  дія записати_дані_розширення(Р: адреса<Розширення>, дані: адреса) {
    Р.дані = дані;
  }

  дія отримати_дані_розширення(Р: адреса<Розширення>): адреса {
    вернути Р.дані;
  }

  дія надрукувати_ю8(Р: адреса<Розширення>, значення: ю8) {
    Р.надрукувати_ю8(Р, значення);
  }

  дія надрукувати_обʼєкт(Р: адреса<Розширення>, обʼєкт: адреса<Обʼєкт>, глибина: позитивне) {
    Р.надрукувати_обʼєкт(Р, обʼєкт, глибина);
  }

  дія взяти_файл_ю8(Р: адреса<Розширення>, назва_модуля: адреса<Назва>, шлях_до_файлу: ю8): Результат {
    вернути Р.взяти_файл_ю8(Р, назва_модуля, шлях_до_файлу);
  }

  дія зберегти_обʼєкт(Р: адреса<Розширення>, обʼєкт: адреса<Обʼєкт>) {
    Р.зберегти_обʼєкт(Р, обʼєкт);
  }

  дія видалити_збережений_обʼєкт(Р: адреса<Розширення>) {
    Р.видалити_збережений_обʼєкт(Р);
  }

  дія назва_з_ю8(Р: адреса<Розширення>, значення: ю8): адреса<Назва> {
    вернути Р.назва_з_ю8(Р, значення);
  }

  дія створити_нативну_дію(Р: адреса<Розширення>, назва: адреса<Назва>, значення: НативнаДія, дані: адреса, відклик_перед_звільненням: ВідкликПередЗвільненнямОбʼєктаНативноїДії): адреса<Обʼєкт> {
    вернути Р.створити_нативну_дію(Р, назва, значення, дані, відклик_перед_звільненням);
  }

  дія створити_число(Р: адреса<Розширення>, значення: д64): адреса<Обʼєкт> {
    вернути Р.створити_число(Р, значення);
  }

  дія створити_текст_з_ю8(Р: адреса<Розширення>, значення: ю8): адреса<Обʼєкт> {
    вернути Р.створити_текст_з_ю8(Р, значення);
  }

  дія створити_юнікод_з_ю8(Р: адреса<Розширення>, значення: ю8): адреса<Обʼєкт> {
    вернути Р.створити_юнікод_з_ю8(Р, значення);
  }

  дія створити_модуль(Р: адреса<Розширення>, назва: адреса<Назва>): адреса<Обʼєкт> {
    вернути Р.створити_модуль(Р, назва);
  }

  дія створити_список(Р: адреса<Розширення>): адреса<Обʼєкт> {
    вернути Р.створити_список(Р);
  }

  дія створити_словник(Р: адреса<Розширення>): адреса<Обʼєкт> {
    вернути Р.створити_словник(Р);
  }

  дія створити_обʼєкт(Р: адреса<Розширення>): адреса<Обʼєкт> {
    вернути Р.створити_обʼєкт(Р);
  }

  дія обʼєкт_виконати(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, обʼєкт_я: адреса<Обʼєкт>, кількість_аргументів: позитивне, аргументи: памʼять<адреса<Обʼєкт>>, іменовані_аргументи: адреса<ІменованіАргументи>): Результат {
    вернути Р.обʼєкт_виконати(обʼєкт, Р, обʼєкт_я, кількість_аргументів, аргументи, іменовані_аргументи);
  }

  дія обʼєкт_отримати_властивість(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>): Результат {
    вернути Р.обʼєкт_отримати_властивість(обʼєкт, Р, назва);
  }

  дія обʼєкт_змінити_властивість(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>, значення: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_змінити_властивість(обʼєкт, Р, назва, значення);
  }

  дія обʼєкт_видалити_властивість(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>): Результат {
    вернути Р.обʼєкт_видалити_властивість(обʼєкт, Р, назва);
  }

  дія обʼєкт_виконати_властивість(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, назва: адреса<Назва>, кількість_аргументів: позитивне, аргументи: памʼять<адреса<Обʼєкт>>, іменовані_аргументи: адреса<ІменованіАргументи>): Результат {
    вернути Р.обʼєкт_виконати_властивість(обʼєкт, Р, назва, кількість_аргументів, аргументи, іменовані_аргументи);
  }

  дія обʼєкт_отримати_елемент(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, ключ: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_отримати_елемент(обʼєкт, Р, ключ);
  }

  дія обʼєкт_змінити_елемент(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, ключ: адреса<Обʼєкт>, значення: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_змінити_елемент(обʼєкт, Р, ключ, значення);
  }

  дія обʼєкт_видалити_елемент(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, ключ: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_видалити_елемент(обʼєкт, Р, ключ);
  }

  дія обʼєкт_отримати_перебір(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат {
    вернути Р.обʼєкт_отримати_перебір(обʼєкт, Р);
  }

  дія обʼєкт_додати(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_додати(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_відняти(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_відняти(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_помножити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_помножити(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_поділити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_поділити(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_остача(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_остача(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_неповна_частка(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_неповна_частка(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_степінь(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_степінь(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_вліво(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_вліво(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_вправо_зі_заповненням(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_вправо_зі_заповненням(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_двійкове_і(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_двійкове_і(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_двійкове_або(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_двійкове_або(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_двійкове_виключне_або(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_двійкове_виключне_або(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_двійкове_не(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат {
    вернути Р.обʼєкт_двійкове_не(обʼєкт, Р);
  }

  дія обʼєкт_більше(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_більше(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_менше(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_менше(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_рівно(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_рівно(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_містить(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_містить(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_є(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, аргумент: адреса<Обʼєкт>): Результат {
    вернути Р.обʼєкт_є(обʼєкт, Р, аргумент);
  }

  дія обʼєкт_відʼємне(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат {
    вернути Р.обʼєкт_відʼємне(обʼєкт, Р);
  }

  дія обʼєкт_числове(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат {
    вернути Р.обʼєкт_числове(обʼєкт, Р);
  }

  дія обʼєкт_заперечити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат {
    вернути Р.обʼєкт_заперечити(обʼєкт, Р);
  }

  дія обʼєкт_збільшити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат {
    вернути Р.обʼєкт_збільшити(обʼєкт, Р);
  }

  дія обʼєкт_зменшити(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): Результат {
    вернути Р.обʼєкт_зменшити(обʼєкт, Р);
  }

  дія отримати_значення_числа(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): д64 {
    вернути Р.отримати_значення_числа(обʼєкт, Р);
  }

  дія виділити<Т>(Р: адреса<Розширення>): адреса<Т> {
    вернути Р.виділити(Р, Т.розмір) як адреса<Т>;
  }

  дія виділити<Т>(Р: адреса<Розширення>, кількість: позитивне): памʼять<Т> {
    вернути Р.виділити(Р, кількість * Т.розмір) як памʼять<Т>;
  }

  дія обробити_падіння(Р: адреса<Розширення>, падіння: адреса<Падіння>, значення: адреса<Обʼєкт>) {
    Р.обробити_падіння(Р, падіння, значення);
  }

  дія звільнити(Р: адреса<Розширення>, значення: адреса) {
    Р.звільнити(Р, значення);
  }

  дія перевірити_чи_обʼєкт_є_дією(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_дією(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_нативною_дією(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_нативною_дією(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_числом(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_числом(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_текстом(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_текстом(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_юнікодом(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_юнікодом(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_модулем(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_модулем(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_списком(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_списком(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_словником(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_словником(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_логічним(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_логічним(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_байтами(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_байтами(обʼєкт, Р);
  }

  дія отримати_копію_даних_тексту(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<текст>): логічне {
    вернути Р.отримати_копію_даних_тексту(обʼєкт, Р, вихід);
  }

  дія отримати_дані_тексту(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<текст>): логічне {
    вернути Р.отримати_дані_тексту(обʼєкт, Р, вихід);
  }

  дія отримати_копію_даних_юнікоду(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: невідома_адреса): логічне {
    вернути Р.отримати_копію_даних_юнікоду(обʼєкт, Р, вихід);
  }

  дія отримати_дані_юнікоду(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: невідома_адреса): логічне {
    вернути Р.отримати_дані_юнікоду(обʼєкт, Р, вихід);
  }

  дія отримати_копію_даних_юнікоду_як_ю8(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<ю8>): логічне {
    вернути Р.отримати_копію_даних_юнікоду_як_ю8(обʼєкт, Р, вихід);
  }

  дія отримати_копію_даних_байтів(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>): позитивне {
    вернути Р.отримати_копію_даних_байтів(обʼєкт, Р, вихід);
  }

  дія отримати_дані_байтів(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>): позитивне {
    вернути Р.отримати_дані_байтів(обʼєкт, Р, вихід);
  }

  дія створити_байти(Р: адреса<Розширення>, розмір: позитивне): адреса<Обʼєкт> {
    вернути Р.створити_байти(Р, розмір);
  }

  дія записати_в_байти(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, дані: памʼять<п8>, розмір: позитивне, зсув: позитивне) {
    Р.записати_в_байти(обʼєкт, Р, дані, розмір, зсув);
  }

  дія отримати_елементи_словника(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<ЕлементСловника>>): позитивне {
    вернути Р.отримати_елементи_словника(обʼєкт, Р, вихід);
  }

  дія перевиділити<Т>(Р: адреса<Розширення>, значення: памʼять<Т>, нова_кількість: позитивне): памʼять<Т> {
    вернути Р.перевиділити(Р, значення як памʼять<п8>, нова_кількість * Т.розмір) як памʼять<Т>;
  }

  дія знайти_іменований_аргумент(Р: адреса<Розширення>, іменовані_аргументи: адреса<ІменованіАргументи>, назва: адреса<Назва>, вихід: адреса<адреса<Обʼєкт>>): логічне {
    вернути Р.знайти_іменований_аргумент(Р, іменовані_аргументи, назва, вихід);
  }

  дія записати_іменований_аргумент(Р: адреса<Розширення>, іменовані_аргументи: адреса<ІменованіАргументи>, назва: адреса<Назва>, значення: адреса<Обʼєкт>) {
    Р.записати_іменований_аргумент(Р, іменовані_аргументи, назва, значення);
  }

  дія виділити_іменовані_аргументи(Р: адреса<Розширення>): адреса<ІменованіАргументи> {
    вернути Р.виділити_іменовані_аргументи(Р);
  }

  дія звільнити_іменовані_аргументи(Р: адреса<Розширення>, іменовані_аргументи: адреса<ІменованіАргументи>) {
    Р.звільнити_іменовані_аргументи(Р, іменовані_аргументи);
  }

  дія створити_адресу(Р: адреса<Розширення>, значення: адреса): адреса<Обʼєкт> {
    вернути Р.створити_адресу(Р, значення);
  }

  дія отримати_значення_адреси(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): адреса {
    вернути Р.отримати_значення_адреси(обʼєкт, Р);
  }

  дія перевірити_чи_обʼєкт_є_адресою(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>): логічне {
    вернути Р.перевірити_чи_обʼєкт_є_адресою(обʼєкт, Р);
  }

  дія отримати_елементи_списку(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<адреса<Обʼєкт>>>): позитивне {
    вернути Р.отримати_елементи_списку(обʼєкт, Р, вихід);
  }

  дія отримати_копію_даних_тексту_як_ю8сі(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>): позитивне {
    вернути Р.отримати_копію_даних_тексту_як_ю8сі(обʼєкт, Р, вихід);
  }

  дія отримати_копію_даних_юнікоду_як_ю8сі(обʼєкт: адреса<Обʼєкт>, Р: адреса<Розширення>, вихід: адреса<памʼять<п8>>): позитивне {
    вернути Р.отримати_копію_даних_юнікоду_як_ю8сі(обʼєкт, Р, вихід);
  }

  дія створити_юнікод_з_ю8сі(Р: адреса<Розширення>, значення: памʼять<п8>): адреса<Обʼєкт> {
    вернути Р.створити_юнікод_з_ю8сі(Р, значення);
  }
}