Введение в Raku

Raku - это универсальный язык высокого уровня с постепенной типизацией. Raku является мультипарадигменным: он поддерживает процедурное, объектно-ориентированное и функциональное программирование.

Чтобы установить Rakudo Star, запустите следующие команды в вашем эмуляторе терминала:

С другими вариантами можно ознакомиться на https://rakudo.org/star/source

Есть четыре варианта:

Запуск кода Raku может быть осуществлён с помощью REPL ("Read-Eval-Print Loop"", цикл «чтение — вычисление — вывод»). Для этого откройте эмулятор терминала, наберите perl6 или raku в командной строке и нажмите [Enter]. После этого должно появиться приглашение командной строки - символ >. Далее напечатайте строку кода и нажмите [Enter]. REPL выведет значение строки. Затем вы можете напечатать другую строку или напечатать exit и нажать [Enter], чтобы покинуть REPL.

Также вы можете написать код в файле, сохранить его и затем запустить. Рекомендуется сохранять Raku скрипт в файл с расширением .p6. Запустите файл, напечатав perl6 имяфайла.p6 в окне эмулятора терминала и нажав [Enter]. В отличии от использования REPL, результат каждой строки не будет автоматически выводиться: для этого код должен содержать инструкции для вывода, к примеру say.

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

Также отдельные строки кода могут быть запущены в командной строке в не-интерактивном режиме вводом perl6 -e 'ваш код' и нажатием [Enter].

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

Лично я пользуюсь и рекомендую Atom. Это современный текстовый редактор, способный "из коробки" подсвечивать синтаксис Raku. Perl 6 FE - альтернативный плагин подсветки кода в Atom, "отколовшийся" от оригинального плагина, содержащий много исправлений и улучшений.

Други люди из нашего сообщества также пользуются Vim, GNU Emacs или Padre.

Последние версии Vim’a имеют подсветку синтаксиса "из коробки". Emacs и Padre потребуют установки дополнительных плагинов.

Нам стоит начать с ритуала hello world.

ещё это можно написать так:

Raku это язык со свободной формой написания: в большинстве случаев вы можете использовать сколько угодно пробелов, хоть и в некоторых случаях пробелы имеют значение.

Инструкции обычно являются логическими строками кода, они должны заканчиваться точкой с запятой: say "Hello" if True;

Выражения являются особым типом инструкций, возвращающим значение: 1+2 вернёт 3

Выражения состоят из Термов и Операторов.

Термами являются:

Классификация операторов:

В таблице ниже приведён список наиболее распространённых операторов.

Добавление R перед любым из операторов меняет местами операнды.

Операторы свёртки работают со списками значений. Они образуются квадратными скобками [] с обеих сторон оператора.

Скаляр содержит одно значение или ссылку.

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

Массивы являются списками, содержащими множество значений.

Как показано на примере ниже, есть множество встроенных операций над массивами:

.elems возвращает количество элементов в массиве.
.push() добавляет один или более элементов в массив.
Мы можем получить доступ к конкретному элементу массива через указание его индекса @animals[0].
.pop удаляет последний элемент массива и возвращает его
.splice(a,b) удалит b элементов, начиная с индекса a.

Вот несколько методов, определённых для хешей:

.push: (key => 'Value') добавляет новую пару ключ-значение.
.kv возвращает список, содержащий все ключи и значения.
.keys возвращает список, содержащий все ключи.
.values возвращает список, содержащий все значения.
Мы можем получить доступ к отдельному значению в хеше, указав его ключ %hash<key>

В прошлых примерах мы не определяли тип значения для переменных.

Как вы можете видеть на примере выше, тип значения $var был сначала (Str), а потом стал (Int).

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

А сейчас попробуйте запустить следующий пример:
Обратите внимание на Int перед именем переменной.

Этот код завершится исключением с таким сообщением: Type check failed in assignment to $var; expected Int but got Str.

Произошло вот что - мы заранее определили, что переменная должна быть типа (Int). Когда же мы попытались присвоить ей (Str), было сгенерировано исключение и выполнение программы прекратилось.

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

Raku классифицируется как язык с постепенной типизацией; он позволяет использовать и статическую, и динамическую типизацию.

Вы, скорее всего, никогда не будете использовать первые два и они упоминаются в ознакомительных целях.

Интроспекция - это процесс получения информации о свойствах объекта, например, его типе.
В одном из прошлых примеров мы использовали .WHAT для получения типов переменной.

Тип переменной, содержащей значение, зависит от этого значения.
Тип строго определённой пустой переменной будет тем типом, который был объявлен.
Пустая переменная без объявленного типа будет иметь тип Any.
Чтобы обнулить значение переменной, присвойте ей Nil.

Прежде чем использовать переменную впервые, она должен быть объявлена.

В Raku используют несколько вариантов объявления области видимости. Пока что мы использовали только my.

Объявление области видимости my присваивает переменной лексическую область видимости. Иными словами, переменная будет доступна только в пределах блока, в котором она была объявлена.

Блок в Raku обозначается { }. Переменные, объявленные за пределами блока, будут доступны во всем скрипте.

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

В предыдущем примере мы видели, как присвоить значение к переменной.
Присвоение совершается используя оператор =.

Мы можем изменить значение, присвоенное переменной:

С другой стороны, мы не можем изменить значение, которое было привязано к переменной.
Привязка (binding) совершается с использованием оператора :=.

Привязка переменных является двунаправленной.
$a := $b и $b := $a имеют один и тот же результат.

Код выполняется только при соблюдённом условии; то есть вычисленное выражение равно True.

В Raku вы можем поменять местами код и условие.
Даже если условие определено после кода, оно всегда будет проверяться в первую очередь.

Если условие не соблюдено, можно описать другой блок для выполнения, используя:

Противоположность оператора if - unless.

Данный код:

может быть записан так:

Логическое отрицание в Raku осуществляется с помощью ! или not.

unless (условие) обычно используется вместо if not (условие).

unless не может иметь ветку else .

with действует как и инструкция if, но проверяет, определена ли переменная.

Если вы запустите код без присвоения значения переменной, ничего не произойдёт.

without является противоположностью with. Эту конструкцию можно сравнить с unless.

Если первое условие with не соблюдено, можно описать альтернативную ветка используя orwith.
with и orwith можно сравнить с if и elsif.

Цикл for обходит множество значений.

Обратите внимание, что мы создали переменную цикла $array-item, а затем осуществили операцию *100 над каждым из элементов массива.

given - эквивалент конструкции "switch" в других языках, но намного круче.

После первого успешного сравнения, процесс выбора остановится.

Если необходимо, proceed позволяет продолжить проверку даже после первого успешного сопоставления.

loop - ещё один способ написать цикл for.

На самом деле, loop - это то, как циклы for записываются в семействе языков программирования C.

Raku принадлежит к этому семейству.

Чтобы запустить команду в командной оболочке, могут быть использованы две подпрограммы:

echo и ls - распространённые команды оболочки в Linux:
echo выводит текст в эмулятор терминала (эквивалент print в Perl 6)
ls выводит список всех файлов и папок в текущей директории

dir эквивалент ls в Windows.

В Raku можно получить список содержимого директории, не прибегая к командам оболочки вроде ls.

Также вы можете создавать и удалять директории.

mkdir создаёт новую директорию.
rmdir удаляет пустую директорию или возвращает ошибку, если она не пуста.

Вы также можете проверить, существует ли путь, является ли он файлом или директорией:

В директории, в которой вы запустите приведённый ниже скрипт, создайте пустую папку folder123 и пустой файл script123.p6

IO.e проверяет, существует ли директория/файл.
IO.f проверяет, ведёт ли путь к файлу.
IO.d проверяет, ведёт ли путь к директории.

ВНИМАНИЕ: Пользователи Windows могут использовать / или \\, чтобы разделять директории
C:\\rakudo\\bin
C:/rakudo/bin

Подпрограммы (также называемые функциями) это средство объединения и повторного использования функциональности.

Определение подпрограммы начинается с ключевого слова sub. После определения, она может быть вызвана по имени.
Рассмотрите следующий пример:

Это пример определения подпрограммы, в которой нет входных данных.

Подпрограмма может зависеть от входных данных. Эти данные передаются посредством аргументов. Подпрограмма может определять ноль либо больше параметров. Количество и тип параметров, которые определены подпрограммой, называются её сигнатурой.

Подпрограмма ниже принимает аргументом строку.

Можно определять несколько подпрограмм с одинаковым именем, но разными сигнатурами. Когда подпрограмма вызывается, окружение времени выполнения определяет, какой вариант использовать, основываясь на количестве и типах переданных аргументов. Такой вид подпрограмм описывается точно так же, как и обычные подпрограммы, но вместо ключевого слова sub используется multi.

Если подпрограмма принимает аргумент, но вызвана без этого необходимого аргумента, произойдёт ошибка.

Raku предоставляет нам возможность определять подпрограммы с:

Опциональный параметр можно определить, добавив ? к его имени.

Если пользователь может не передавать аргумент, можно определить значение по умолчанию.
Это делается с помощью присвоения значению параметру в определении подпрограммы.

Все подпрограммы, которые мы пока видели, делали что-то — они выводили некий текст в терминал.

Но иногда мы вызываем подпрограмму для её возвращаемого значения, которое мы можем позднее использовать в потоке выполнения программы.

Если поток выполнения тела функции доходит до конца блока, последняя инструкция или выражение будет использоваться как возвращаемое значение.

Для большей ясности, хорошо явно указывать, что мы возвращаем. Это можно сделать используя ключевое слово return.

Функции/подпрограммы это объекты первого класса:

Наглядным примером является функция map.
map это функция высшего порядка, она может принимать другую функцию как аргумент.

Мы определили подпрограмму с именем squared, которая принимает аргумент и умножает его на себя.
Далее, мы использовали map, функцию высшего порядка, и передали ей два аргумента: подпрограмма squared и массив.
Результат - список элементов массива, возведённых в квадрат.

Отметьте, что при передаче подпрограммы аргументом, мы должны добавлять & в начале её имени.

Анонимные функции также называют лямбдами.
Анонимная функция не привязана к идентификатору (у неё нет имени).

Давайте перепишем пример с map, используя анонимную функцию

Отметьте, что вместо объявления подпрограммы для получения квадрата и передачи её аргументом к map, мы определили её внутри анонимной подпрограммы как -> $x {$x ** 2}.

В жаргоне Perl 6, мы называем такую нотацию заостренный блок (pointy block)

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

К примеру, для данного массива, необходимо вернуть уникальные значения массива, отсортированные от наибольшего до наименьшего.

Вот решение без сцепления:

В этом случае, мы вызываем unique на @array, передаём результат как аргумент в sort, а затем передаём результат в reverse.

Напротив, с сцеплением методов, пример выше может быть переписан как:

Как можно увидеть, сцепление методов гораздо проще читать.

Оператор ленты, называемый конвейером в некоторых функциональных языках программирования, развивает нотацию сцепления методов.

Отметьте, что порядок вызовов методов сверху-вниз — от первого до последнего шага.

Обратная лента работает как прямая, но в противоположную сторону.
Порядок вызовов методов снизу-вверх — от последнего до первого шага.

Гипер оператор >>. вызовет метод для каждого из элементов списка и вернёт список результатов.

Используя гипер оператор мы можем вызывать методы, уже определённые в Raku, например, is-prime, который определяет является ли число простым или нет.
Вдобавок мы можем определять новые подпрограммы и вызывать их, используя этот оператор. В этом случае нам необходимо добавлять & перед именем метода, например, &is-even.

Такой подход очень практичен в том смысле, что освобождает от необходимости писать цикл for для обхода каждого значения.

Скрещение это логическая суперпозиция значений.

В примере ниже, 1|2|3 это скрещение.

Использование функций обычно вызывает автоматический трединг; операция производится над каждым элементом скрещения, а все результаты собираются в новое скрещение и возвращаются.

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

Преимущества такого подхода:

Для создания ленивого списка, мы используем инфиксный оператор …​
Ленивый список имеет начальные элементы (один либо больше), генератор и предел.

Начальный элемент - 1, а предел - 10. Генератор не был определён, поэтому используется генератор по умолчанию - следующий элемент (+1)
Иными словами, ленивый список может вернуть (если необходимо) следующие элементы: (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Этот список вернёт, если необходимо, любое целое число от 1 до бесконечности, то есть любое целое число.

Начальные элементы здесь 0 и 2, а предел - 10. Мы не определили генератор, но используя начальные значения, Raku "выведет", что генератор это (+2)
Такой список вернёт, если необходимо, следующие элементы: (0, 2, 4, 6, 8, 10)

В этом примере, мы явно определили генератор, заключённый в скобки { }
Этот ленивый список может вернуть (если необходимо) следующие элементы: (0, 3, 6, 9, 12)

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

Если вы запустите код выше, он выведет Good Morning John Doe в эмуляторе терминала.
Хотя результат очень простой, этот пример интересен тем, что внутренняя подпрограмма greeting была возвращена из внешней до своего вызова.

$generated стала замыканием.

Замыкание это особый вид объекта, который содержит две вещи:

Окружение состоит из всех локальных переменных, которые были в области видимости во время создания замыкания. В этом случае, $generated это замыкание, которое объединяет подпрограмму greeting и строку John Doe, которая существовала, когда замыкание было создано.

Давайте взглянем на более интересный пример.

В этом примере, мы определили подпрограмму greeting-generator($period), которая принимает новую подпрограмму. Подпрограмма, которую она возвращает, принимает единственный аргумент $name и возвращает созданное приветствие.

По сути, greeting-generator это фабрика подпрограмм. В этом примере, мы использовали greeting-generator, чтобы создать две подпрограммы, одна из которых выводит Good Morning, а другая - Good Evening.

$morning и $evening это замыкания. Они разделяют одинаковое тело подпрограммы, но разные окружения.
В окружении $morning, $period это Morning. В окружении $evening, $period это Evening.

Объектно-ориентированное программирование это одна из широко используемых сегодня парадигм программирования.
Объект - это набор переменных и подпрограмм, объединенный в одну сущность.
Переменные называются атрибутами, а подпрограммы - методами.
Атрибуты определяют состояние, а методы определяют поведение объекта.

Класс это шаблон для создания объектов.

Для того, чтобы понять это отношение, рассмотрим следующий пример:

В объектно-ориентированном жаргоне, мы называем объекты экземплярами класса.

Рассмотрим следующий скрипт:

Ключевое слово class используется для определения класса.
Ключевое слово has используется для определения атрибутов класса.
Метод .new() вызывает конструктор. Он создаёт объект как экземпляр класса, для которого он был вызван.

В скрипте выше, новая переменная $john содержит ссылку на новый экземпляр класса "Human", определённую вызовом Human.new().
Аргументы переданные в метод .new() используются для установки значений атрибутов созданного объекта.

Классу можно присвоить лексическую область видимости используя my:

Инкапсуляция это концепция объектно-ориентированного программирования, которая состоит в том, чтобы объединять наборы данных и методов вместе.
Данные (атрибуты) внутри объекта должны быть приватными, иными словами, доступными только лишь изнутри этого объекта.
Для того, чтобы обратиться к атрибутам не в теле метода объекта, мы используем методы, называемые ацессоры(методы доступа).

Два скрипта ниже имеют одинаковый результат.

Метод sayvar это метод доступа. Он позволяет нам получать доступ к значению переменной без прямого обращения к ней.

Инкапсуляция в Raku упрощается с использованием твигилов.
Твигилы это вторичные сигилы. Они находятся между сигилом и именем атрибута.
В классах используются два твигила:

По умолчанию, все атрибуты приватные, но считается хорошей привычкой всегда использовать твигил !.

Таким образом, мы можем переписать класс выше как:

Добавьте в скрипт следующую инструкцию: say $john.age;
Повторный запуск скрипта выведет такую ошибку: Method 'age' not found for invocant of class 'Human' потому что $!age приватный и может быть использован лишь внутри объекта. Попытка обратиться к нему снаружи объекта создаст исключение.

Теперь замените has $!age на has $.age и проверьте результат инструкции say $john.age;

В Raku все классы наследуют стандартный конструктор .new().
Он может быть использован для создания объектов и принимает аргументы.
Стандартный конструктор может принимать только именованные аргументы.
Отметьте, что в примере выше аргументы, переданные в .new(), определены по имени:

Что, если я не хочу указывать имя атрибута каждый раз, когда создаю объект?
Тогда мне нужно создать ещё один конструктор, который принимает позиционные аргументы.

Атрибуты класса - это атрибуты, которые принадлежат самому классу, а не его объектам.
Они могут быть инициализированы при его объявлении.
Атрибуты класса объявляются с помощью my вместо has.
Они вызываются для самого класса, а не его объектов.

До этого момента, все примеры, которые мы видели, использовали ацессоры для того, чтобы получить информацию из атрибутов объектов.

Что, если нам нужно модифицировать значение атрибута?
Нам нужно отметить его доступным для чтения/записи, используя ключевое слова is rw

По умолчанию все атрибуты объявлены только для чтения, но вы можете указать это явно, используя is readonly

В Perl 6 доступно множественное наследование. Класс может быть потомком множества других классов.

Класс combo-chart должен содержать два ряда, один для значений, отображённых на гистограмме, и другой для прогнозируемых значений, построенных на линии.
Именно поэтому мы определили его как потомка line-chart и bar-chart.
Вы могли заметить, что вызов метода plot у combo-chart не возвращает желаемый результат. Только один ряд был построен.
Почему так произошло?
combo-chart наследует от line-chart и bar-chart, и у оба эти класса содержат метод с названием plot. Когда мы вызываем его для combo-chart, Raku попробует разрешить этот конфликт, вызвав один из унаследованных методов.

Для того, чтобы выполняться корректно, нам следует переопределить метод plot для combo-chart.

Роли похожи на классы в том смысле, что являются наборами атрибутов и методов.

Роли объявляются с помощью ключевого слова role. Классы, которые реализовывают роль, делают это с помощью ключевого слова does.

Запустите скрипт выше и вы увидите, что результаты одинаковы.

Сейчас вы спрашиваете себя: если роли ведут себя как классы, в чём их польза?
Чтобы ответить на этот вопрос, измените первый скрипт, который показывает множественное наследование, так, будто мы забыли переопределить метод plot.

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

Роли предупредят вас, что существует конфликт.

Интроспекция это процесс получения информации об объекте, такой как его тип, атрибуты или методы.

Интроспекция упрощается с помощью:

Исключения это особое поведение, которое происходит во время выполнения, когда что-то идёт не так.
Говорится, что исключения выбрасываются.

Рассмотрите скрипт ниже, который выполняется корректно:

Теперь рассмотрите скрипт, который выбрасывает исключение:

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

Обработка исключений - это процесс ловли исключений, которые были выброшены, для того, чтобы скрипт продолжал работу.

Исключения обрабатываются используя блок try-catch.

Блок CATCH может быть определён также, как блок given. Это означает, что мы можем ловить и обрабатывать по разному много типов исключений.

В Raku можно выбрасывать исключение явно.
Два типа исключений могут быть выброшены:

Ad-hoc исключения создаются, используя подпрограмму die, которая принимает сообщение исключения.

Типизированные исключения это объекты, поэтому было необходимо использовать конструктор .new() в примере выше.
Все типизированные исключения являются потомками класса X , вот несколько примеров:
X::AdHoc это простейший тип исключения
X::IO относится к ошибкам ввода-вывода
X::OS относится к ошибкам ОС
X::Str::Numeric относится к попытке привести строку к числу

Регулярное выражение можно определять так:

Если не указано явно, символы пробела игнорируются; m/light/ и m/ light / означают одно и то же.

Алфавитные символы и цифры, а также нижнее подчёркивание _ означают сами себя.
Все остальные символы должны быть экранированы, используя обратную косую черту или взяты в кавычки.

Символы могут быть классифицированы по категориям и мы можем сравнивать с ними.
Мы также можем сравнивать с инверсией этой категории (всё, кроме неё):

Сравнение с категорией символов, как мы видели в предыдущем разделе, очень удобно.
При этом, более систематическим подходом будет использовать свойства (property) Юникода.
Это позволяет нам сравнивать с категорией символов, которые входят и не входят в стандарт ASCII.
Свойства Юникода заключаются в <: >

Также в регулярных выражениях можно использовать "символ подстановки" или "wildcard".

Точка . означает один любой символ.

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

Знак вопроса ? означает ноль или один раз.

Астериск (звёздочка) * означает ноль или больше раз.

+ означает как минимум один раз.

Когда процесс сравнения строки с регулярным выражением успешен, его результат хранится в специальной переменной $/

$/ возвращает объект Match (строку, которая отвечает регулярному выражению)
Вот часть методов, определённых для объекта Match:
.prematch возвращает строку, предшествующую совпадению.
.postmatch возвращает строку, идущую после совпадения.
.from возвращает начальную позицию совпадения.
.to возвращает конечную позицию совпадения.

Давайте проверим, корректный ли электронный адрес или нет.
Для простоты примера мы предположим, что корректный электронный адрес имеет формат:
имя [dot] фамилия [at] компания [dot] (com/org/net)

john.doe@perl6.org is a valid email

<:L> совпадает с одной буквой
<:L>` совпадает с одной или больше буквами + `\.` совпадает с одним символом [dot] + `\@` совпадает с одним символом [at] + `<:L:N> совпадает с буквой или цифрой
<:L+:N>+ совпадает с одной или более буквой либо цифрой

Это регулярное выражение можно разделить на части так:

Именованный регэксп определяется, используя следующий синтаксис: my regex regex-name { regex definition }
Именованный регэксп может быть использован, используя следующий синтаксис: <regex-name>

MD5 это криптографическая хеш-функция, результатом которой является 128-битное значение хеша.
У MD5 есть множество применений в приложениях, включая шифрование паролей, хранящихся в базе данных. Когда новый пользователь регистрируется, его данные хранятся не в чистом виде, а в хешированом. Идея заключается в том, что если база данных будет скомпрометирована, атакующий не сможет узнать пароли.

К счастью, нам не нужно реализовывать алгоритм MD5 вручную; существует модуль, написанный на Raku, где это реализовано.

Давайте установим его:
zef install Digest::MD5

Теперь, запустите скрипт ниже:

Для того, чтобы вызвать функцию md5_hex(), которая создаёт хеши, нам нужно загрузить соответствующий модуль.
Ключевое слово use загружает модуль, чтобы его можно было использовать в скрипте.

Три строчки выше являются примером разных способов построения символа:

Буква á может быть написана:

NFC возвращает уникальный код символа.
NFD декомпозирует символ и возвращает коды символов всех частей.
uniname возвращает имя кода символа.

Обычно, все задачи в программе выполняются последовательно.
Чаще всего это не является проблемой, если то, что вы пытаетесь сделать, не занимает много времени.

К счастью, в Raku есть возможности, которые позволяют вам выполнять процессы параллельно.
На этом этапе важно отметить, что параллелизм может означать одно из двух понятий:

Давайте начнём со второго.

Рассмотрим код на языке Си, который определяет функцию под названием hellofromc. Эта функция выводит в терминал Hello from C. Она не принимает никаких аргументов и не возвращает никакого значения.

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

В той же директории, где вы скомпилировали Си библиотеку, создайте новый скрипт на Raku, который содержит код ниже, и запустите его.

Сперва мы объявили, что будем использовать модуль NativeCall.
После этого мы создали константу LIBPATH, которая содержит путь к Си библиотеке.
Отметьте, что $*CWD возвращает текущую рабочую директорию.
После этого мы создали подпрограмму под названием hellofromc(), которая служит обёрткой для своей дополняющей функции на Си, с таким же именем и находящуюся в Си библиотеке, которую можно найти в пути LIBPATH.
Всё это сделано используя трейт is native.
Наконец, мы вызываем нашу подпрограмму в Raku.

В сущности, всё сводится к объявлению подпрограммы с трейтом is native и именем Си библиотеки.

В подразделе выше, мы видели, как можно вызвать очень простую функцию на Си, обернув её с помощью подпрограммы в Raku с таким же именем, используя трейт is native.

В некоторых случаях, может быть предпочтительно изменить имя подпрограммы Raku.
Для этого, мы используем трейт is symbol.

Давайте изменим скрипт выше на Raku и назовём Raku подпрограмму hello вместо hellofromc

В случае, когда подпрограмма в Raku имеет имя отличное от своего Си дополнения, нам следует использовать трейт is symbol с именем оригинальной функции на Си.

Скомпилируйте код модифицированной библиотеки Си и запустите скрипт на Raku, которые указаны ниже.
Отметьте, что мы изменили и код на Си и код на Raku для того, чтобы принимать аргументом строку (char* в Cи и Str в Raku)

Повторим процесс, создав простой калькулятор, который принимает 2 целых числа и складывает их.
Скомпилируйте Си библиотеку и запустите Raku скрипт.

Отметьте, что и функция на Си и функция на Raku принимают два целых числа и возвращают одно (int в Cи и int32 в Raku)

Возможно, вы задаётесь вопросом, почему мы использовали int32 вместо Int в последнем скрипте на Raku.
Часть типов в Raku, такие как Int, Rat и некоторые другие, не могут передаваться или быть возвращены значением из функции на Cи.

Необходимо использовать такие же типы в Raku, как в Cи.

К счастью, Raku предоставляет много типов для того, чтобы представлять соответствующий тип в Cи.