Увод в Perl 6

Perl 6 е език от високо ниво, с общо предназначение и постепенна типизация на променливите. Perl 6 е многопарадигмен. Той поддържа процедурно, обектно-ориентирано и функционално програмиране.

За да видите други възможности за инсталация, посетете http://rakudo.org/how-to-get-rakudo/\#Installing-Rakudo-Star-Linux

Имате четири възможности:

Можете да изпълнявате код на Пърл 6, като използувате директно неговата интерактивна конзола - REPL (Read-Eval-Print Loop). За да направите това, отворете терминал, напишете perl6 в терминала и натиснете [Enter]. Това ще отвори конзолата и в нея ще се появи >. След това напишете някакъв програмен код и натиснете [Enter]. На следващия ред в конзолата ще се появи резултатът от изпълнението на кода. Въведете друг ред, съдържащ програмен код, или въведете exit и натиснете [Enter], за да напуснете конзолата (REPL).

Друг начин за изпълнение е, като въведете програмния код във файл, запишете го и го изпълните. Препоръчва се за разширение на скриптовете, написани на Пърл 6, да се използува .pl6. Изпълнете файла, като напишете в терминал perl6 filename.pl6 и натиснете [Enter]. За разлика от интерактивната конзола (REPL), всеки ред код ще се изпълни последователно, но резултатът не ще се изпише на екрана автоматично. Кодът трябва да съдържа израз, използуващ командата say, за да изведе нещо на стандартния изход (екрана).

Интерактивната конзола се използува най-вече за пробване на специфични парченца код, обикновено едноредови изрази. За програми, състоящи се от повече редове, се препоръчва да се записват във файл и след това да се изпълняват.

Едноредови изрази могат да се изпробват и на командния ред без интерактиванта конзола, като напишете perl6 -e 'your code here' и натиснете [Enter].

Тъй като през повечето време ще записваме програмите си във файлове, ни е нужен приличен текстов редактор, който разпознава синтаксиса на Пърл 6.

Аз лично използувам и препоръчвам Atom. Това е модерен редактор и поддържа синтаксиса на Пърл 6. Perl6 FE е допълнителен пакет за оцветяване на кода на Пърл 6 за Атом. Той произхожда от оригиналния пакет, който идва с Атом, но съдържа много подобрения и поправени грешки.

Други членове на общността използуват също Vim, Emacs или Padre.

По-новите версии на Vim идват по подразбиране с поддръжка на синтаксиса на Пърл 6. Emacs и Padre изискват инсталиране на допълнителни пакети.

Ще започнем с ритуала hello world.

Това може да бъде написано и така:

Пърл 6 е свободна форма: Свободни сте (през повечето време) да използувате колкото ви е угодно празни пространства (за разлика от Питон - бел. прев.).

Твърденията са обикновено логически ред код. Те завършват с точка и запетая.
say "Здрасти" if True;

Изразите са специален тип твърдение, което връща стойност: 1+2 ще върне 3

Изразите се състоят от Членове и Оператори.

Членове. Те са:

Оператори. Те са няколко типа:

Следващата таблица изрежда най-често използуваните оператори.

Добавяне на R преди който и да е оператор ще обърне операндите му.

Операторите за съкращения се прилагат върху списък от стойности. Съставят се, като операторът се огради със []

Скаларът (Scalar) съдържа единична стойност или указател (reference).

В зависимост от стойността, която съдържа скаларната променлива (нейния тип), върху нея могат да се извършват различни действия.

Масивите (Arrays) са списъци, които съдържат множество стойности.

От долния пример се вижда, че върху масивите могат да се извършват много операции:

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

Някои от методите, които могат да се извикват върху хешове, са:

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

В примерите досега не задавахме типа стойност, който да съдържа променливата.

Както виждате от горния пример, типът на стойността в променливата $var първо беше (Str), а след това (Int).

Този начин на програмиране се нарича динамично типизиране. Динамично означава, че променливите могат да съдържат стойности от Всякакъв (Any) тип.

Сега опитайте да изпълните следния пример. Обърнете внимание на използуването на Int пред името на променливата.

Присвояването ще се провали и ще върне следната грешка:
Type check failed in assignment to $var; expected Int but got Str
Проверката за тип е неуспешна при присвояване на $var; очакваше се Int, но бе подаден Str

Този път указахме, че типа на променливата ще бъде (Int). Опитът да му присвоим низ (Str) не беше успешен.

Този начин на програмиране се нарича статично типизиране. Статично означава, че типа на променливите се указва предварително и не може да бъде променян.

Пърл 6 е постепенно типизиран; позволява и статично, и динамично типизиране.

Най-вероятно никога няма да използувате първите два, но са упоменати, да ги знаете.

Самонаблюдение (Introspection) е действието по взимане на информация за даден обект, например какъв е типът му.
В един от предишните примери използувахме .WHAT, за да върнем типа на променливата.

Типът на дадена променлива показва каква стойност може да съдържа.
Типът на твърдо обявена празна променлива е типът, с който е била обявена.
Типът на празна променлива, която не е твърдо обявена, е Всякакъв (Any)
За да изчистите стойността на променлива, присвойте ѝ Nil.

Преди да използувате променлива за първи път, трябва да я обявите.

В Пърл 6 се използуват няколко начина за обявяване на променливи. В примерите досега използувахме my.

Операторът my дава на променливата словна (lexical) видимост. Иначе казано, променливата ще бъде видима (използваема) само в блока от код, в който е обявена.

В Пърл 6 блокът представлява всичко, намиращо се между двойка отваряща и затваряща фигурни скоби - { }. Ако няма определен блок, променливата е достъпна в целия скрипт.

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

В предишните примери видяхме как да присвояваме стойности на променливи.
Присвояването се прави с помощта на оператора =.

Можем да променим стойността, присвоена на променлива:

И напротив - когато обвързваме стойност с променлива, не можем да променим стойността.
Обвързването се извършва с помощта на оператора :=.

Обвързването на променливи една с друга е двупосочно.
Резултатът от $a := $b и $b := $a е един и същ.

Кодът се изпълнява, само ако условието е изпълнено. Иначе казано - ако изразът се изчисли като Истина (True).

В Пърл 6 можем да сменим местата на условието и кода.
Макар местата да са сменени, проверката на условието винаги се изпълнява първа.

В случай че условието не се изпълни, можем да укажем алтернативни блокове код чрез:

Отрицанието на твърдението, проверявано чрез if, може да бъде изразено чрез unless.

Следният код:

може да бъде написан като:

Отрицание на дадено твърдение се постига чрез ! или not.

unless (условие) се използува вместо if not (условие).

unless не може да има съответстваща else клауза.

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

Ако изпълните кода, без да сте присвоили стойност на променливата, нищо няма да се изведе на екрана.

without е обратното на with. Същото, каквото е unless за if.

Ако първото with условие не е изпълнено, може да укажете друго условие с orwith.
with и orwith са подобни на if и elsif.

Цикълът for повтаря действието върху множество стойности.

Забележете, че създадохме променливата $array-item и приложихме действието *100 върху всеки елемент от масива.

given в Пърл 6 е същото като switch в другите езици, но много по-мощно.

При успешно съвпадение, процесът на търсене на удовлетворяване на условието, следващо when, се прекратява.

Ако обаче добавите proceed в блока за изпълнение, процесът на търсене на съвпадение продължава.

loop е друг начин за писане на for цикъл.

Всъщност loop е начинът, по който се пишат for циклите в езиците, подобни на C.

Пърл 6 принадлежи към това семейство.

Две подпрограми могат да се използуват за извикване на външни команди:

echo и ls са познати команди от обвивката в Linux:
echo отпечатва текст в терминала (същото като print в Perl 6)
ls показва списък от файлове и папки в текущата папка

dir е същото като ls, но в Windows.

Perl 6 може да покаже списък от папки и файлове без помощта на системни команди (например като използвате ls).

Освен това, можете да създавате и триете папки.

mkdir създава нова папка.
rmdir изтрива празна папка. Връща грешка, ако не е празна.

Също така можете да проверявате дали указаният път съществува, дали е файл или папка:

В папката, където ще изпълните долния скрипт, създайте празна папка folder123 и празен файл с разширение pl6 script123.pl6

IO.e проверява дали файлът съществува.
IO.f проверява дали указаният път е файл.
IO.d проверява дали указаният път е папка.

Подпрограмите (наричани също функции) са начин да се събере накуп набор от действия (функционалност) и да се използва по-късно.

За да създадете подпрограма, напишете ключовата дума sub, последвана от името на подпрограмата. След това подпрограмата може да бъде извиквана чрез изписване на името ѝ.
Разгледайте примера:

В този пример е показана подпрограма, която не изисква никакви входни данни.

Подпрограмите могат да изискват входни данни. Тези данни се предоставят чрез подаване на параметри. Една подпрограма може да няма никакви или да има няколко параметъра. Броят и типът на параметрите на една подпрограма се наричат сигнатура (от лат. signatura — обозначение, бел. прев.).

Може да създадете няколко подпрограми с едно и също име, но различен списък от параметри (многократно). Когато подпрограмата бъде извикана, средата за изпълнение ще реши коя от тях да изпълни, в зависимост от типа и броя на подадените параметри. Този тип подпрограми се създават както обикновено, но като използувате ключовата дума multi вместо sub.

Ако сте създали подпрограма, приемаща един параметър и я извикате, без да ѝ подавате нищо, изпълнението ще се провали.

Пърл 6 ни дава възможност да създаваме подпрограми с:

Незадължителните параметри се задават, като в края на името на параметъра (променливата) се добави ?.

Ако потребителят не подаде параметър, той може да приема стойност по подразбиране.
Това се постига, като присвоим стойността, когато създаваме подпрограмата.

Всички подпрограми дотук правят нещо, показват някакъв текст в терминала.

Понякога обаче, може да поискаме подпрограмата да върне някаква стойност, която да използуваме по-късно в приложението.

По подразбиране, резултатът от изпълнението на последния ред в нашата подпрограма е стойността, която тя връща.

За по-голяма яснота, е добра идея изрично да укажем какво връщаме. Това се прави с ключовата дума return.

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

Прекрасен пример е функцията map.
map е функция от високо ниво, тя приема друга функция като параметър.

Създадохме подпрограма, наречена squared, която повдига на квадрат всяко подадено ѝ число.
След това използувахме map, функция от високо ниво, и подадохме два параметъра - функция и масив.
Изходът е списък от елементите на масива, повдигнати на квадрат.

Забележете, че когато подаваме функция като параметър, трябва да поставим пред името ѝ знака &.

Безименната функция се нарича още ламбда.
Безименната функция не е обвързана с идентификатор (тя няма име).

Нека пренапишем примера с map, като използуваме безименна функция.

Забележете, че вместо да обявяваме подпрограма и да я подаваме като параметър на map, ние я създадохме направо в безименната подпрограма -> $x {$x ** 2}.

На жаргона на Пърл 6 наричаме това записване остър блок

В Пърл 6 методите могат да бъдат извиквани верижно, така че да не се налага да подавате изхода от един метод на друг.

Ето едно неверижно решение:

Първо извикваме функцията unique, като ѝ подаваме @array. След това подаваме изхода от нея на sort и накрая подаваме изхода от подреждането на reverse.

Но можем да се възползваме от възможността за верижно извикване на методи и да запишем примера по следния начин:

Вече виждате, че верижното извикване е по-лесно за четене.

Операторът за подаване, наричан тръба в някои езици за програмиране, представя още по-добре верижното извикване.

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

Подаването назад е като подаването напред, но наобратно.
Последователността на извикване на методите е отдолу нагоре – от последната към първата стъпка.

Свръх-операторът (hyper operator) >>. ще извика даден метод върху всички елементи от един списък и ще върне списък с резултатите.

Можем да използуваме свръх-оператора и с вградените методи в Пърл 6, например is-prime, който ни казва дали едно число е просто.
Също така, можем да създаваме нови подпрограми и да ги извикваме чрез свръх-оператора. В този случай трябва да поставим & пред името на метода, например &is-even.

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

Сливането (junction) е логическо съпоставяне на стойности.

В израза долу 1|2|3 е сливане.

Използуването на сливания предизвиква автоматично създаване на нишки (autothreading); операцията се извършва за всеки елемент от сливането, като всички резултати са събрани в ново сливане и върнати.

Мързелив списък е този, който е изчислен мързеливо.
Мързеливо означава отлагане на изчислението на даден израз до момента, когато е необходимо, и избягване повторение на изчислението, като се съхранява резултата в паметта.

Ползите са:

За да построим мързелив списък, използуваме вмъкнатия оператор …​.
Мързеливият списък има начален(лни) елемент(и), генератор (начин за създаване на списъка – бел. прев.) и край.

Началният елемент е 1, а крайният е 10. Не е определен генератор за създаване на списъка, така че се използува подразбиращият се генератор – последователно нарастване с единица (+1)
С други думи, този мързелив списък (ако е необходимо) ще върне следните елементи (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Този списък може да върне (ако е необходимо) всяко цяло число между 1 и безкрайност, т.е. всяко цяло число.

Първоначалните елементи са 0 и 2, а крайният елемент – 10. Не е определен генератор, но Пърл 6 ще изведе генератора от първоначалните елементи (+2). Този мързелив списък може да върне (ако е необходимо) елементите (0, 2, 4, 6, 8, 10).

В този пример определихме изрично генератор, ограден с { }.
Този списък би върнал (ако е нужно) елементите (0, 3, 6, 9, 12).

Всички съставени от код обекти в Пърл 6 са затваряния (closures). Това означава, че те могат да се обръщат към лексикални (частни) променливи от заобикалящия ги блок.

Ако изпълните горния код, той ще изпише Good Morning John Doe в терминала.
Изходът от изпълнението е прост, но интересното в примера е, че вътрешната подпрограма greeting бива върната от външната, преди да е изпълнена.

$generated е затваряне.

Затварянето е специален обект, съчетаващ две неща:

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

Да видим и по-интересен пример.

В този пример създадохме подпрограма greeting-generator($period), която приема един аргумент $period и връща нова подпрограма. Върнатата подпрограма приема един аргумент $name и връща съставения поздрав.

Всъщност, greeting-generator е "фабрика" за подпрограми. В този пример използвахме greeting-generator, за да създадем две подпрограми. Едната казва Good Morning, а другата – Good Evening.

$morning и $evening са затваряния. Те са създадени по един и същи начин, но съхраняват различно обкръжение.
В обкръжението на $morning $period е Morning. В обкръжението на $evening $period е Evening.

Обектно-ориентираното програмиране е една от широко използуваните парадигми напоследък. Обектът е набор от променливи и подпрограми, събрани заедно. Променливите се наричат атрибути (член-променливи), а подпрограмите – методи. Атрибутите определят състоянието, а методите определят поведението на обекта.

Класът е образец (шаблон) за създаване на обекти.

За да разберем взаимовръзката, нека разгледаме следния пример:
(Превеждам и програмния код на български, просто защото е възможно и той ще работи. Не е ли това прекрасно? Пробвайте го в конзолата. Бел. прев.)

На обектно-ориентиран жаргон казваме, че обектите са инстанции (отделни случаи) на един клас.

Да разгледаме следния скрипт:

Ключовата дума class се използува за определяне на класа.
Ключовата дума has (има) се използува, за да определи член-променливите на класа.
Методът .new() се нарича конструктор. Той създава обекта като отделен случай на класа, върху който е извикан.

В скрипта горе $иван съдържа указател към нов случай на "Човек", определен чрез Човек.new().
Параметрите, подадени на метода .new(), се използуват за определяне членовете на новосъздадения обект.

На класа може да се даде лексикална видимост, като се използува my:

Капсулирането (Encapsulation) е понятие в обектно-ориентираното програмиране, което групира набор от данни и методи заедно. Данните (атрибути) трябва да са частни, тоест, достъпни само от вътрешността на обекта. За достъп до данните се използуват методи, наречени аксесори (от access – достъп, бел. прев.).

Двата скрипта долу имат един и същ изход.

Методът sayvar е аксесор. Той опосредства достъпа до променливата, без да имаме пряк достъп до нея.

Капсулирането е улеснено в Пърл 6 чрез използуването на втори знак (twigil). Вторият знак е вторичен сиджил. Той се поставя между първия знак и името на атрибута.
Два вида втори знак се използуват в класовете:

По подразбиране всички член-променливи са частни, но е добър навик винаги да се ползва ! като втори знак.

Затова, трябва да пренапишем горния клас както следва:

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

Сега заместете has $!age с has $.age и вижте изхода при изпълнение на say $john.age;

В Пърл 6 всички класове наследяват готов конструктор .new().
Той може да бъде използуван за създаване на обекти, като му се подават параметри.
На готовия конструктор могат да се подават само именувани параметри.
В предишния пример, ще видите, че всички параметри, подадени на .new(), са именувани.

Какво, ако не искаме да подаваме името на всеки атрибут, когато създаваме обект?
Тогава трябва да създадем конструктор, който приема позиционни параметри.

Клас-атрибутите са такива, които принадлежат на класа, а не на обекта, създаден от него.
На тях могат да им се дават стойности при обявяването им.
Клас-атрибутите се обявяват с помощта на my, вместо has.
Те се извикват непосредствено върху класа, вместо върху обектите.

Дотук във всички примери използувахме атрибутите само за да вземем информация за обектите.

Как да променим стойността на някой атрибут?
Трябва да го означим като променяем за-писане/за-четене чрез ключовите думи is rw.

По подразбиране всички атрибути се обявяват като само за четене, но можете и изрично да зададете is readonly.

Пърл 6 поддържа множествено наследяване. Един клас може да наследява множество класове.

Класът combo-chart ще съдържа два списъка със стойности – един за текущите стойности, изобразени с колонки, и един за прогнозните стойности, изобразени с линия.
Ето защо го създадохме като дъщерен клас на line-chart и bar-chart.
Сигурно забелязахте, че извикването на метода plot върху combo-chart не върна искания резултат. Бе изобразен само един списък.
Защо се случи това?
combo-chart наследява едновременно от line-chart и bar-chart. И двата класа имат метод plot. Когато извикаме този метод върху combo-chart, Пърл 6 ще разреши противоречието, като избере един от наследените методи.

За да получим желаното поведение, трябва да презапишем метода plot в combo-chart.

Ролите са донякъде подобни на класовете, понеже също се състоят от методи и атрибути.

Ролите се обявяват с помощта на ключовата дума role. Класовете, които искат да осъществят (имплементират) една роля, трябва да го направят, като използуват ключовата дума does (3 л. ед. ч. на глагола правя – бел. прев.).

Пуснете скрипта и ще видите, че изходът е същият като от предишния скрипт.

И сега се питате: Ако ролите се държат като класове, каква полза от тях?
За да си отговорите на този въпрос, променете първия скрипт, в който показахме множественото наследяване. Този, в който забравихме да презапишем метода plot.

Ако множество роли са приложени на един и същи клас и се появи противоречие, по време на компилиране ще бъде хвърлена грешка. Това е много по-сигурен подход, в сравнение с множественото наследяване, където такива противоречия не се смятат за грешка и биват разрешавани автоматично по време на изпълнение.

Ролите ви предупреждават, че има противоречие.

Самонаблюдение (Introspection) е действието, при което вземаме информация за свойствата на един обект. Такива са неговите атрибути, методи или тип.

Разполагаме със следните средства за самонаблюдение:

Изключенията (Exceptions) представляват специално поведение, което се случва по време на изпълнение, когато нещо се обърка.
Казваме, че програмата ни хвърля изключение.

Да погледнем следния скрипт. Той работи както трябва.

Сега да видим този скрипт. Той хвърля изключение.

Сигурно вече сте забелязали, че при грешка (в този случай присвояване на цяло число на променлива с тип Str) програмата винаги спира и следващите редове не се изпълняват, дори да са правилно написани.

Обработка на изключението е действието, при което прихващаме изключение, което е било хвърлено, за да продължи работата на програмата ни.

Обработката на изключението се извършва с помощта на блока try-catch (пробвай-хвани).

Блокът, в който прихващаме изключението (CATCH), може да бъде обявен по същия начин както given. Това означава, че можем да прихващаме и обработваме по различен начин много типове изключения.

Пърл 6 ви дава възможност и изрично да хвърляте изключения. Могат да бъдат хвърляни два типа изключения:

Случайните изключения се хвърлят, като се използува вградената функция die, последвана от обяснително съобщение за грешката.

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

Шаблонът за търсене на съвпадение може да бъде обявен както следва:

Празното пространство няма значение, освен ако не е указано нещо друго. m/light/ и m/ light / са едно и също нещо.

Буквено-цифровите знаци и знакът за подчертаване _ се пишат по обичайния начин. Всички други символи трябва да се избягват с обратно наклонена черта или да се ограждат с кавички.

Знаците могат да бъдат групирани в категории, а ние можем да търсим съвпадение по тях. Можем също така да търсим по обратното значение на категорията (всичко друго освен нея).

Да се намира съвпадение чрез категории от знаци е удобно. Въпреки това, по-систематичен подход би бил да се използуват уникод-свойства. Уникод-свойствата са оградени с <: >.

При търсене на съвпадения могат да се ползуват и заместващи знаци.

Точката . дава съвпадение с всякакъв знак.

Количествените указатели се поставят след знак и указват колко пъти се очаква появата на знака в текста.

Въпросителният знак ? означава нула или един път.

Звездата * означава нула или повече пъти.

+ означава поне веднъж.

Когато се намери съвпадение на търсенето в някакъв текст, резултатът се съхранява в специалната променлива $/.

$/ връща Обект на Съвпадението (низът, който съответства на търсения шаблон).
Следните методи могат да се извикат върху Обекта на съвпадението:
.prematch връща низа преди съвпадението.
.postmatch връща низа, следващ съвпадението.
.from връща мястото в низа (цяло число), където съвпадението започва.
.to връща мястото в низа (цяло число), където съвпадението свършва.

Нека проверим дали един адрес за електронна поща е валиден.
За целите на примера ще приемем, че адресът се състои от:
име [точка] фамилия [при] фирма [точка] (com/org/net)

john.doe@perl6.org is a valid email

<:L> съвпада с отделна буква
<:L>` съвпада с една или повече букви + `\.` съвпада с един знак [точка] + `\@` съвпада с един знак [при] + `<:L:N> съвпада с низ, състоящ се от една или повече букви и число в края
<:L+:N>+ съвпада с низ, състоящ се от един или повече знаци (букви и числа)

Изразът може да бъде разложен както следва:

Синтаксисът за обявяване на именуван израз за съвпадение е: my regex regex-name { regex definition }
Синтаксисът за извикване на именуван израз за съвпадение е: <regex-name>

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

За наше щастие вече има модул в Пърл 6, който имплементира алгоритъма MD5. Да го инсталираме:
zef install Digest::MD5

Сега пуснете скрипта по-долу:

За да извикаме функцията md5_hex(), трябва да заредим модула, който я предоставя.
Ключовата дума use зарежда модула в скрипта.

Трите реда горе показват различни начини за изграждане на един знак:

Буквата á може да се напише:

NFC връща точката на кода.
NFD разглобява знака и връща кодовата точка на всяка негова част.
uniname връща името на кодовата точка.

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

За щастие Пърл 6 позволява да се изпълняват няколко задачи едновременно. Тук е важно да споменем, че успоредност може да означава едно от следните две неща:

Да започнем с второто.