Все о Perl 6

Perl 6 по прежнему остается Perl. Что это означает ? Конечно же это не значит, что Perl 6 обладает такой же функциональностью или синтаксически совместим с Perl 5. В таком случае это была бы очередная версия Perl 5. Perl является философией и оба языка, Perl 5 и Perl 6, разделяют ее. Согласно этой философии существует больше одного способа достичь результата , а также простые вещи должны оставаться простыми, а сложные - возможными. Эти принципы связаны с прошлым, настоящим и будущим Perl и определяют фундаментальное предназначение Perl 6. В Perl 6 легкие вещи стали более легкими, а трудные - более возможными.

Являясь спецификацией, Perl 6 подразумевает неограниченное количество реализаций. Любая из реализаций, успешно проходящая тесты, может назвать себя "Perl 6". Примеры, приведенные в книге, могут быть выполнены как с помощью компилятора Rakudo Perl 6 (наиболее развитой на момент написания книги), так и любой другой.

Подробные инструкции по установке Rakudo доступны по адресу http://www.rakudo.org/how-to-get-rakudo. Доступны как исходные тексты для сборки, так и уже предварительно скомпилированный пакет для Windows: http://sourceforge.net/projects/parrotwin32/files/.

Если вы являетесь пользователем FreeBSD, то для установки достаточно выполнить команду:

    pkg_add -r rakudo

Проверить правильность установки Rakudo можно с помощью команды:

 perl6 -e 'say "Hello world!"'

В случае неудачи, проверьте наличие пути для запуска perl6 в переменной PATH. Есть так же переменная PERL6LIB, с помощью которой можно использовать дополнительные модули для Perl 6. Для этого необходимо указать пути к ним в вашей системе аналогично PERL5LIB для Perl 5.

Если вы хотите принять участие в развитии языка Perl 6, поделится своим опытом воспользуйтесь следующими ресурсами:

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

Как изменить программу если строка с именами игроков отсутствует ? Подсказка: %hash.keys возвращает список всех ключей %hash.

Ответ: Достаточно удалить строку my @names = $file.get.split(' ');, и внести изменения в код:

 my @sorted = @names.sort({ %sets{$_} }).sort({ %matches{$_} }).reverse;

... чтобы стало:

 my @sorted = B<%sets.keys>.sort({ %sets{$_} }).sort({ %matches{$_} }).reverse;

2. Вместо удаления избыточной строки, ее можно использовать для контроля наличия всех упомянутых в ней игроков среди результатов матча. Например, для обнаружения опечаток в именах. Каким образом можно изменить программу, чтобы добавить такую функциональность ?

Ответ: Ввести еще один хэш, в котором хранить в качестве ключей правильные имена игроков, а затем использовать его при чтении данных сетов:

    ...
    my @names = $file.get.split(' ');
    my %legitimate-players;
    for @names -> $n {
        %legitimate-players{$n} = 1;
    }

    ...

    for $file.lines -> $line {
        my ($pairing, $result) = $line.split(' | ');
       my ($p1, $p2)          = $pairing.split(' vs ');
        for $p1, $p2 -> $p {
            if !%legitimate-players{$p} {
                say "Warning: '$p' is not on our list!";
            }
        }

        ...
    }

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

        my @scores = 'Ana' => 8, 'Dave' => 6, 'Charlie' => 4, 'Beth' => 4;

.. в правой части присваивания определен список ( согласно оператору ,), состоящий из пар ( благодаря => ), а затем присваивается переменной-массиву. Глядя на данное выражение вполне можно придумать другие способы интерпретации. Например Perl 5 интерпретирует как :

  (my @scores = 'Ana') => 8, 'Dave' => 6, 'Charlie' => 4, 'Beth' => 4;

... так что в @scores будет содержаться только один элемент. А остальная часть выражения воспринимается как список констант и будет отброшена.

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

На самом деле существует два оператора присваивания с разными приоритетом. Когда в правой части указан скаляр, используется оператор присваивания еденичного значения с высоким приоритетом. Иначе используется списочный оператор присваивания, который имеет меньший приоритет. Это позволяет следующим выражениям $a = 1, $b = 2 и @a = 1, 2 означать ожидаемое от них: присвоение значений двум переменным в списке и присвоение списка из двух значений одной переменной.

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

        say 5 - 7 / 2;          # 5 - 3.5  = 1.5
        say (5 - 7) / 2;        # (-2) / 2 =  -1

В приведенной ниже таблице приоритет убывает сверху вниз.

Есть несколько способов сравнения объектов в Perl. Можно проверить равенство значений используя инфиксный оператор ===. Для неизменных (immutable) объектов ( значения которых нельзя изменить, литералов. Например литерал 7 всегда будет 7) это обычное сравнение значений. Например 'hello'==='hello' всегда верно потому, что обе строки неизменны и имеют одинаковое значение.

Для изменяемых объектов === сравнивает их идентичность. === возвращает истину, если его аргументы являются псевдонимами одного и того же объекта. Или же двое объектов идентичны, если это один и тот же объект. Даже если оба массива @a и @b содержат одинаковые значения, если их контейнеры разные объекты, они будут иметь различные идентичности и не будут тождественны при сравнении ===:

        my @a = 1, 2, 3;
        my @b = 1, 2, 3;

        say @a  === @a;        # 1
        say @a  === @b;        # 0

        # здесь используется идентичность 
        say 3   === 3;         # 1
        say 'a' === 'a';   # 1

        my $a = 'a';
        say $a === 'a';         # 1

Оператор eqv возвращает Истина если два объекта одного типа и одинаковой структуры. Так для @a и @b указанных в примере, @a eqv @b истинно потому, что @a и @b содержат одни и те же значения. С другой стороны '2' eqv 2 вернет False, так как аргумент слева строка, а справа - число, и таким образом они разных типов.

        say 1 == 1.0;          # 1
        say 1 == '1';          # 1
        say 1 == '2';          # 0
        say 3 == '3b'          # 1

        my @colors = <red blue green>;

        if @colors == 3 {
           say "It's true, @colors contains 3 items";
        }

        if $greeting eq 'hello' {
           say 'welcome';
        }

        say 10   <=> 5;           # +1
        say 10   leg 5;           # because '1' lt '5'
        say 'ab' leg 'a';         # +1, lexicographic comparison

        say ~<abstract Concrete>.sort;
        # output: Concrete abstract

        say ~<abstract Concrete>.sort:
               -> $a, $b { uc($a) leg uc($b) };
        # output: abstract Concrete

        if $pints-drunk ~~ 8 {
           say "Go home, you've had enough!";
        }

        if $country ~~ 'Sweden' {
           say "Meatballs with lingonberries and potato moose, please."
        }

        unless $group-size ~~ 2..4 {
           say "You must have between 2 and 4 people to book this tour.";
        }

Определение подпрограммы состоит из нескольких частей. Сперва следует декларатор sub, указывающий начало определения подпрограммы. Затем - необязательное имя и необязательная сигнатура. И наконец - тело подпрограммы: ограниченный фигурными скобками блок кода. Этот код выполняется каждый раз при вызове подпрограммы.

К примеру, в коде:

    sub panic() {
        say "Oh no! Something has gone most terribly wrong!";
    }

... определена подпрограмма с именем panic. Ее сигнатура отсутствует, а тело состоит их единственного оператора say.

По умолчанию, подпрограммы ограничена областью лексической видимости, как и любая переменная объявленная с помощью my. Это подразумевает, что подпрограмма может быть вызвана, только в границах той области видимости ( Как правило это блок кода ), внутри которой она была определена. Чтобы подпрограмма стала доступной внутри всего пакета используется декларатор (ключевое слово) our:

    {
        our sub eat() {
            say "om nom nom";
        }

        sub drink() {
            say "glug glug";
        }
    }

    eat();    # om nom nom
    drink();  # fails, can't drink outside of the block

our также делает подпрограмму видимой вне пакета или модуля:

    module EatAndDrink {
         our sub eat() {
             say "om nom nom";
         }

         sub drink() {
             say "glug glug";
         }
    }
    EatAndDrink::eat();    # om nom nom
    EatAndDrink::drink();  # fails, not declared with "our"

Чтобы подпрограмма стала доступна в другой области видимости, используется экспорт (см. Экспортирование).

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

Подпрограммы первого класса позволяют решать сложные задачи. Например, для создания небольшого ASCII рисунка с изображением танцующих фигур, возможно построение хэша, ключами которого будут названия движений в танце, а значениями - анонимные подпрограммы. Допустим, что пользователи могут вводить названия списки движений ( возможно с коврика для танцев или другого экзотического устройства). Как можно организовать легко изменяемый список движений, а также возможно безопасно сделать проверку вводимых пользователем названий движений на предмет допустимых ? Возможно следующая структура программы станет отправной точкой для достижения результата:

    my $dance = '';
    my %moves =
        hands-over-head => sub { $dance ~= '/o\ '   },
        bird-arms       => sub { $dance ~= '|/o\| ' },
        left            => sub { $dance ~= '>o '    },
        right           => sub { $dance ~= 'o< '    },
        arms-up         => sub { $dance ~= '\o/ '   };

    my @awesome-dance = <arms-up bird-arms right hands-over-head>;

    for @awesome-dance -> $move {
        %moves{$move}.();
    }

    say $dance;

На основании вывода этой программы, вы сможете убедиться что танец YMCA ^[1] также плохо выглядит в ASCII виде, как и в реальной жизни.

Сигнатура подпрограммы решает две задачи. Во первых, она объявляет список обязательных и необязательных аргументов, передаваемых при вызове подпрограммы. Во вторых, с помощью сигнатуры объявляются переменные и их связь с аргументами подпрограммы. Эти переменные называются параметрами. Сигнатуры в Perl 6 обладают дополнительными возможностями: они позволяют ограничивать значения аргументов, сравнивать и извлекать сложные структуры данных.

    sub order-beer($type, $pints) {
        say ($pints == 1 ?? 'A pint' !! "$pints pints") ~ " of $type, please."
    }

    order-beer('Hobgoblin', 1);    # A pint of Hobgoblin, please.
    order-beer('Zlatц+ Baе+ant', 3); # 3 pints of Zlatц+ Baе+ant, please.

    sub make-it-more-so($it is rw) {
        $it ~= substr($it, $it.chars - 1) x 5;
    }

    my $happy = "yay!";
    make-it-more-so($happy);
    say $happy;                # yay!!!!!!
    make-it-more-so("uh-oh");  # Fails; can't modify a constant

    sub say-it-one-higher($it is copy) {
        $it++;
        say $it;
    }

    my $unanswer = 41;
    say-it-one-higher($unanswer);  # 42
    say-it-one-higher(41);         # 42

    sub shout-them(@words) {
        for @words -> $w {
            print uc("$w ");
        }
    }

    my @last_words = <do not want>;
    shout-them(@last_words);  # DO NOT WANT
    shout-them('help');       # Fails; a string is not Positional

    sub do-it-lots(&it, $how-many-times) {
        for 1..$how-many-times {
            it();
        }
    }

    do-it-lots(sub { say "Eating a stroopwafel" }, 10);

Иногда требуется заполнить позиционные аргументы значениями из массива. Вместо написания eat(@food[0], @food[1], @food[2], ...) и так далее, вы можете линеаризовать (flatten) его в список аргументов предварив вертикальной чертой: eat(|@food).

Кроме того, можно интерполировать хэши в именованные аргументы:

    sub order-shrimps($count, $from) {
        say "I'd like $count pieces of shrimp from the $from, please";
    }

    my %user-preferences = ( from => 'Northern Sea' );
    order-shrimps(3, |%user-preferences)

    sub order-steak($how = 'medium') {
        say "I'd like a steak, $how";
    }

    order-steak();
    order-steak('well done');

    sub order-burger($type, $side?) {
       say "I'd like a $type burger" ~
           ( defined($side) ?? " with a side of $side" !! "" );
    }

    order-burger("triple bacon", "deep fried onion rings");

    sub order-beer($type, $pints) {
        say ($pints == 1 ?? 'A pint' !! "$pints pints") ~ " of $type, please."
    }

    order-beer(type => 'Hobgoblin', pints => 1);
    # A pint of Hobgoblin, please.

    order-beer(pints => 3, type => 'ZlatГ?? BaЕ??ant');
    # 3 pints of ZlatГ?? BaЕ??ant, please.

    sub order-shrimps($count, :$from = 'North Sea') {
        say "I'd like $count pieces of shrimp from the $from, please";
    }

    order-shrimps(6);                       # takes 'North Sea'
    order-shrimps(4, from => 'Atlantic Ocean');
    order-shrimps(22, 'Mediterranean Sea'); # not allowed, :$from is named only

    sub design-ice-cream-mixture($base = 'Vanilla', :$name!) {
        say "Creating a new recipe named $name!"
    }

    design-ice-cream-mixture(name => 'Plain');
    design-ice-cream-mixture(base => 'Strawberry chip'); # missing $name

    sub announce-time(:dinner($supper) = '8pm') {
        say "We eat dinner at $supper";
    }

    announce-time(dinner => '9pm');      # We eat dinner at 9pm

    sub paint-rectangle(
            :$x      =   0,
            :$y      =   0,
            :$width  = 100,
            :$height =  50,
            :color(:colour($c))) {

       # print a piece of SVG that reprents a rectangle
       say qq[<rect x="$x" y="$y" width="$width" height="$height"
                     style="fill: $c" />]
    }

    # both calls work the same
    paint-rectangle :color<Blue>;
    paint-rectangle :colour<Blue>;

    # of course you can still fill the other options
    paint-rectangle :width(30), :height(10), :colour<Blue>;

    announce-time(dinner => '9pm');
    announce-time(:dinner('9pm'));
    announce-time(:dinner<9pm>);

    toggle-blender( :enabled); # enables  the blender
    toggle-blender(:!enabled); # disables the blender

    my $dinner = '9pm';
    announce-dinner :$dinner;  # same as dinner => $dinner;

    # TODO: better example
    my $black = 12;
    my %color-popularities = :$black, :blue(8),
                             red => 18, :white<0>;
    # same as
    # my %color-popularities = 
    #       black => 12,
    #       blue  => 8,
    #       red   => 18,
    #       white => 0;

    sub mix(@ingredients, :$name) { ... }    # OK
    sub notmix(:$name, @ingredients) { ... } # Error

    sub shout-them(*@words) {
        for @words -> $w {
            print uc("$w ");
        }
    }

    # now you can pass items
    shout-them('go');           # GO
    shout-them('go', 'home');   # GO HOME

    my @words = ('go', 'home');
    shout-them(@words);         # still works

    sub debug-wrapper(&code, *@positional, *%named) {
        warn "Calling '&code.name()' with arguments "
             ~ "@positional.perl(), %named.perl()\n";
        code(|@positional, |%named);
        warn "... back from '&code.name()'\n";
    }

    debug-wrapper(&order-shrimps, 4, from => 'Atlantic Ocean');

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

    my %moves =
       hands-over-head => sub { return '/o\ '   },
       bird-arms       => sub { return '|/o\| ' },
       left            => sub { return '>o '    },
       right           => sub { return 'o< '    },
       arms-up         => sub { return '\o/ '   };

    my @awesome-dance = <arms-up bird-arms right hands-over-head>;

    for @awesome-dance -> $move {
        print %moves{$move}.();
    }

    print "\n";

Подпрограммы в Perl могут возвращать несколько результатов:

    sub menu {
        if rand < 0.5 {
            return ('fish', 'white wine')
        } else {
            return ('steak', 'red wine');
        }
    }

    my ($food, $beverage) = menu();

Если опустить оператор return, Perl вернет значение последнего оператора, выполненного внутри подпрограммы. Это упрощает предидущий пример:

    sub menu {
        if rand < 0.5 {
            'fish', 'white wine'
        } else {
            'steak', 'red wine';
        }
    }

    my ($food, $beverage) = menu();

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

return имеет дополнительный эффект при раннем завершении подпрограммы:

    sub create-world(*%characteristics) {
        my $world = World.new(%characteristics);
        return $world if %characteristics<temporary>;

        save-world($world);
    }

... в таком случае новая переменная $world точно не будет потеряна и будет возвращена в качестве ответа.

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

    sub mean(Numeric $a, Numeric $b) {
        return ($a + $b) / 2;
    }

    say mean 2.5, 1.5;
    say mean 'some', 'strings';

    2
    Nominal type check failed for parameter '$a';
        expected Numeric but got Str instead

    sub circle-radius-from-area(Numeric $area where { $area >= 0 }) {
        ($area / pi).sqrt
    }

    say circle-radius-from-area(3);    # OK
    say circle-radius-from-area(-3);   # Error

    sub set-volume(Numeric $volume where 0..11) {
        say "Turning it up to $volume";
    }

    my %in-stock = 'Staropramen' => 8, 'Mori' => 5, 'La Trappe' => 9;

    sub order-beer(Str $name where %in-stock) {
        say "Here's your $name";
        %in-stock{$name}--;
        if %in-stock{$name} == 0 {
            say "OH NO! That was the last $name, folks! :'(";
            %in-stock.delete($name);
        }
    }

В каком-то смысле, сигнатура представляет собой "коллекцию" аргументов. Захватывания (captures) представляют собой сущности того же уровня. Так же, как вы редко думаете о сигнатуре в целом, сосредотачиваясь на каждом отдельно взятом параметре, так же редко вы должны редко думать о "захватываниях". Однако, Perl 6 позволяет управлять захватываниями напрямую. Захватывания состоят из позиционных и именованных частей, которые действуют аналогично спискам и хэшам соответственно. Списочная часть содержит позиционные аргументы, а хэш составляющая - именованные аргументы.

    sub act($left, $right, :$action) {
        $action($left, $right);
    }

    my @tasks = \(39, 3, action => { say $^a + $^b }),
                \(6, 7, action => { say $^a * $^b });

    for @tasks -> $task-args {
        act(|$task-args);
    }

    my $value     = 7;
    my $to-change = \($value);

    sub double($x is rw) {
        $x *= 2;
    }

    sub triple($x is rw) {
        $x *= 3;
    }

    triple(|$to-change);
    double(|$to-change);

    say $value; # 42

    sub visit-czechoslovakia(|$plan) {
        warn "Sorry, this country has been deprecated.";
        visit-slovakia(|$plan);
        visit-czech-republic(|$plan);
    }

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

    sub first-is-largest(@a) {
        my $first = @a.shift;
        # TODO: either explain junctions, or find a
        # concise way to write without them
        return $first >= all(@a);
    }

    # same thing:
    sub first-is-largest(@a) {
        my :($first, *@rest) := \(|@a)
        return $first >= all(@rest);
    }

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

    sub first-is-largest([$first, *@rest]) {
        return $first >= all(@rest);
    }

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

Таким же образом можно распаковать хэш, используя %(...) вместо квадратных скобок. В таком случае доступны только именованные параметры, а не позиционные.

    sub create-world(%(:$temporary, *%characteristics)) {
        my $world = World.new(%characteristics);
        return $world if $temporary;

        save-world($world);
    }

Рассмотрим модуль, предложенный в качестве примера в секции "Необязательные параметры":

    sub order-burger( $type, $side? ) { ... };

Если вы часто используете order-burger и в основном вместе с картофелем фри, то наличие процедуры order-burger-and-fries может оказаться кстати:

    sub order-burger-and-fries ( $type ) {
        order-burger( $type, side => 'french fries' );
    }

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

    sub order-the-usual ( $side? ) {
        if ( $side.defined ) {
            order-burger( 'veggie', $side );
        }
        else {
            order-burger( 'veggie' );
        }
    }

Карринг позволяет создавать сокращения для подобных применений. С помощью карринга создается новая подпрограмма на основе существующей с некоторыми предустановленными параметрами. В Perl 6, карринг создается методом .assuming:

    &order-the-usual        := &order-burger.assuming( 'veggie' );
    &order-burger-and-fries := &order-burger.assuming( side => 'french fries' );

Новая подпрограммы похожи на другие и поддерживают одни и те же структуры входных параметров.

    order-the-usual( 'salsa' );
    order-the-usual( side => 'broccoli' );

    order-burger-and-fries( 'plain' );
    order-burger-and-fries( :type<<double-beef>> );

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

    sub logarithm(Numeric $x, Numeric :$base = exp(1)) {
        log($x) / log($base);
    }

    my @params = &logarithm.signature.params;
    say @params.elems, ' parameters';

    for @params {
        say "Name:       ", .name;
        say "  Type:     ", .type;
        say "  named?    ", .named    ?? 'yes' !! 'no';
        say "  slurpy?   ", .slurpy   ?? 'yes' !! 'no';
        say "  optional? ", .optional ?? 'yes' !! 'no';
    }

    2 parameters
    Name:       $x
      Type:     Numeric()
      named?    no
      slurpy?   no
      optional? no
    Name:       $base
      Type:     Numeric()
      named?    yes
      slurpy?   no
      optional? yes

Сигил & и следующее за ним имя подпрограммы представляют собой объект соответствующей подпрограммы. &logarithm.signature возвращает сигнатуру подпрограммы, а метод .params у сигнатуры - список параметров в виде объектов типа Parameter. Объекты Parameter описывают детали каждого параметра в отдельности

Анализ сигнатур позволяет создавать интерфейсы, которые могут анализировать ожидаемые сигнатурами данные, а затем передавать правильные данные в подпрограммы. Например, возможно создание программы-генератора web форм, которая будет создавать интерфейс пользователем, проверять введенные данные и затем обрабатывать их на основе информации полученной с помощью анализа сигнатур. Подобный подход позволяет также облегчить создание инструментов для работы в командной строке, обеспечивая справочную информацию о параметрах ввода.

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

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

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

Определение класса создает объект-тип, который по умолчанию становиться доступным внутри текущего пакета ( аналогично переменным, определенным с помощью our ). Этот объект-тип является "пустым экземпляром" класса. С ними мы встречались в предыдущих главах. Например, каждый из типов Int и Str относятся к объектам-типам одного из встроенных в Perl 6 классов. Код примера в начале главы демонстрирует, как имя класса Task может использоваться в роли ссылки в дальнейшем, например для создания экземпляров класса вызывая метод new.

Объекты-типы не определены в том смысле, что они возвращают значение False если вызвать их метод .defined. Эту особенность можно использовать чтобы узнать является ли какой-либо объект объектом-типом или нет:

    my $obj = Int;
    if $obj.defined {
        say "Ordinary, defined object";
    } else {
        say "Type object";
    }

В примере, первые три строки в блоке класса:

        has      &!callback;
        has Task @!dependencies;
        has Bool $.done;

определяют атрибуты ( в других языках они могут называться полями или хранилищем экземпляра). Атрибуты действительно являются индивидуальным местом хранения данных для каждого созданного объекта. Так же как переменные созданные с помощью my не могут быть доступны извне области их видимости так и атрибуты объектов доступны только внутри класса. Данная особенность является основой объекто-ориентированного проектирования и называется инкапсуляцией.

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

    has &!callback;

Сигил & указывает, что аттрибут представляет собой нечно вызываемое (invocable). Символ ! является твигилом (twigil), или выражаясь иначе - вторым сигилом. Твигил является частью имени переменной. В данном случае твигил ! подчеркивает что данный атрибут является приватным (собсвенным, private), то есть недоступен вне класса.

Определение второго атрибута класса Task также содержит приватный твигил:

    has Task @!dependencies;

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

Третий атрибут хранит статус готовности задачи:

    has Bool $.done;

Этот скалярный атрибут ( сигил $ ) имеет тип Bool. Вместо твигила ! используется твигил .. В то время как инкапсуляция атрибутов является в Perl 6 полноценной, язык позволяет избавиться от необходимости явно создавать методы доступа к атрибутам из вне (accessor methods). Замена ! на . помимо определения атрибута $!done определит метод доступа done. То есть результат будет тот же, как если вы написали бы следующий код:

    has Bool $!done;
    method done() { return $!done }

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

Стоит заметить что твигил . создает метод с доступом к атрибуту только в режиме чтения. Чтобы пользователи этого объекта могли сбросить статус готовности задачи (для выполнения ее например повторно) можно изменить определение атрибута на следующее:

    has Bool $.done is rw;

traits, is rw

Свойство is rw приводит к генерации метода доступа c возможностью модифицировать значение атрибута.

В то время как атрибуты определяют состояние объекта, методы определяют его поведение. Пропустим временно специальный метод new и рассмотрим второй метод add-dependency, который добавляет новую задачу к списку зависимостей для текущей задачи.

    method add-dependency(Task $dependency) {
        push @!dependencies, $dependency;
    }

В большинстве случаев, определение метода похоже на определение sub. Однако имеется два важных отличия. Во первых, определение подпрограммы как метода добавляет ее к списку методов текущего класса. Благодаря этому у любого экземпляра класса Task можно вызвать необходимый метод с помощью оператора вызова .. Во вторых, метод сохраняет своего инвоканта в специальной переменной self.

Рассматриваемому метод передается один параметр, экземпляр класса Task, который затем добавляется к содержимом атрибута инвоканта @!dependencies.

Следующий метод содержит основную логику обработки зависимостей:

    method perform() {
        unless $!done {
            .perform() for @!dependencies;
            &!callback();
            $!done = True;
        }
    }

Он вызывается без параметров и использует атрибуты объекта. Сначала анализируется атрибут $!done, который является признаком выполненной задачи. Если этот атрибут содержит значение "истина", то задача выполнена и никаких действий не производится.

Иначе метод выполняет все зависимости для задачи, используя конструкцию for для поочередного обхода всех элементов в атрибуте @!dependencies. Этот цикл во время итерации размещает каждый элемент ( экземпляр класса Task ) в topic переменной $_. При использовании оператора вызова метода . без явного указания инвоканта используется текущая topic переменная. Таким образом производится вызов метода .perform() у каждого объекта Task, хранящихся в атрибуте @!dependencies текущего инвоканта.

После того, как все зависимые задачи завершены, наступает время выполнить текущую задачу Task. Это производится с помощью прямого вызова атрибута &!callback ( после атрибута указываются круглые скобки). В итоге атрибуту $!done присваивается значение True ("Истина") и это гарантирует, что при последующем вызове метода perform этого объекта никаких повторных действий производится не будет.

В отношении конструкторов Perl 6 является более либеральным, чем большинство языков программирования. Главное чтобы конструктор возвращал экземпляр класса. Кроме того, конструкторами в Perl 6 являются обычные методы. Любой класс наследует конструктор с именем new от базового класса Object. Этот метод new может быть переопределен, например, как в следующем коде:

    method new(&callback, Task *@dependencies) {
        return self.bless(*, :&callback, :@dependencies);
    }

В то время, как конструкторы в языках подобных C# и Java устанавливают состояние уже предварительно созданных объектов, конструкторы в Perl 6 непосредственно создают объекты. Наиболее простой путь создать объект - это вызвать метод bless, который наследуется от Object. В качестве параметров метод bless ожидает позиционный параметр, так называемого "кандидата", и набор именованных параметров с начальными значениями для каждого из атрибутов объекта.

В конструкторе из примера позиционные параметры преобразуются в именованные. Благодаря этому конструктор оказывается лаконичным и простым для использования. Первый параметр конструктора new представляет собой callback ( непосредственно действие, из которого состоит задача ). Остальными параметрами являются экземпляры класса Task. Конструктор захватывает их в массив и передает затем как именованный параметр в bless ( заметьте, что для в форме именованного параметра :&callback непосредственно имя параметра тоже что и имя переменной за вычетом сигила, т.е. callback ).

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

    my $eat = Task.new({ say 'eating dinner. NOM!' });

Ранее рассказывалось, что после определении класса Tast появляется так называемый объект-тип. Он является своеобразным "пустым экземпляром" класса, а именно экземпляром без определенного состояния. Для него возможно вызывать какие угодно методы, кроме тех которые пытаются получить доступ к состоянию объекта ( например к свойствам ). Так new, например, создает новый объект, а не модифицирует или пытается прочесть состояние существующего объекта.

К сожалению, обеда не происходит волшебно неожиданно. Он имеет зависимые задачи:

    my $eat =
        Task.new({ say 'eating dinner. NOM!' },
            Task.new({ say 'making dinner' },
                Task.new({ say 'buying food' },
                    Task.new({ say 'making some money' }),
                    Task.new({ say 'going to the store' })
                ),
                Task.new({ say 'cleaning kitchen' })
            )
        );

Обратите внимание на уровни отступов. Такое форматирование позволяет сделать нагляднее структуру зависимостей для задач.

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

    making some money
    going to the store
    buying food
    cleaning kitchen
    making dinner
    eating dinner. NOM!

Объектно Ориентированное Программирование определяет концепцию наследования как как механизм для повторного использования кода. Perl 6 поддерживает как наследование одного класса от другого, так и множественное наследование ( от нескольких классов ).Когда класс наследуется от другого, диспетчер методов следует по цепочке наследования, чтобы определить метод для вызова. Это поведение одинаково как для определенных стандартным способом, с помощью ключевого слова method, так и для генерируемых методов для доступа к свойствам объекта (attribute accessors).

    class Employee {
        has $.salary;

        method pay() {
            say "Here is \$$.salary";
        }

    }

    class Programmer is Employee {
        has @.known_languages is rw;
        has $.favorite_editor;

        method code_to_solve( $problem ) {
            say "Solving $problem using $.favorite_editor in " 
            ~ $.known_languages[0] ~ '.';
        }
    }

Теперь любой объект типа Programmer может использовать методы и аксессоры ( методы для доступа к атрибутам ), определенные в классе Employe, так словно они определены в классе Programmer.

    my $programmer = Programmer.new(
        salary => 100_000, 
        known_languages => <Perl5 Perl6 Erlang C++>,
        favorite_edtor => 'vim'
    );

    $programmer.code_to_solve('halting problem');
    $programmer.pay();

    class Cook is Employee {
        has @.utensils  is rw;
        has @.cookbooks is rw;

        method cook( $food ) {
            say "Cooking $food";
        }

        method clean_utensils {
            say "Cleaning $_" for @.utensils;
        }
    }

    class Baker is Cook {
        method cook( $confection ) {
            say "Baking a tasty $confection";
        }
    }

    my $cook = Cook.new( 
        utensils => (<spoon ladel knife pan>), 
        cookbooks => ('The Joy of Cooking'), 
        salary => 40000);

    $cook.cook( 'pizza' ); # Cooking pizza

    my $baker = Baker.new(
        utensils => ('self cleaning oven'), 
        cookbooks => ("The Baker's Apprentice"), 
        salary => 50000);

    $baker.cook('brioche'); # Baking a tasty brioche

    class GeekCook is Programmer is Cook {
        method new( *%params ) {
            push( %params<cookbooks>, "Cooking for Geeks" );
            return self.bless(%params);
        }
    }

    my $geek = GeekCook.new( 
        books           => ('Learning Perl 6'), 
        utensils        => ('blingless pot', 'knife', 'calibrated oven'),
        favorite_editor => 'MacVim',
        known_languages => <Perl6>
    );

    $geek.cook('pizza');
    $geek.code_to_solve('P =? NP');

Интроспеция ^[4] процесс сбора информации об объектах в программе во время ее выполнения.

Возьмем объект $o класса Programmer и, основываясь на содержимом классов из предыдущей секции, зададим несколько вопросов:

    if $o ~~ Employee { say "It's an employee" };
    if $o ~~ GeekCook { say "It's a geeky cook" };
    say $o.WHAT;
    say $o.perl;
    say $o.^methods(:local).join(', ');

Результат будет выглядеть следующим образом:

    It's an employee
    Programmer()
    Programmer.new(known_languages => ["Perl", "Python", "Pascal"], favorite_editor => "gvim", salary => "too small")
    code_to_solve, known_languages, favorite_editor

Первые два теста представляют собой умное сопоставление (smart-match) объекта с именами классов. Если объект того же класса или наследуется от указанного, результатом является истина. Таким образом образом $o является объектом класса Employee или унаследованным от него, но не GeekCook.

Метод .WHAT возвращает объект-тип, ассоциированный с объектом $o, который сообщает точный класс. В данном примере - Programmer.

$o.perl возвращает исполняемую строку кода Perl, которая воссоздает оригинальный объект $o. Данный код в основном не является работающим ^[5], но очень полезен для отладки простых объектов.

Наконец, $o.^methods(:local) выводит список доступных для вызовов методов объекта $o. Именованный параметр :local ограничивает этот список методами определенными в классе Employee и исключает унаследованные.

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

    say $o.^attributes.join(', ');
    say $o.^parents.join(', ');  

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

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

1. Метод add-dependency в классе Task позволяет создавать циклические зависимости в графе зависимостей между задачами. Это значит, что если вы будете продвигаться по ссылкам между задачами, то вернетесь к исходной. Таким образом образуется бесконечный цикл и метод perform класса Task никогда не завершиться. Покажите как создать такой граф.

Ответ: Вы можете создать две задачи, а затем "замкнуть" их с помощью метода add-dependency следующим образом:

    my $a = Task.new({ say 'A' });
    my $b = Task.new({ say 'B' }, $a);
    $a.add-dependency($b);

Метод perform никогда не завершиться, потому что он первым делом будет вызывать perlform своих зависимостей. А так как $a и $b зависят друг от друга, никто из них не завершить вызовы callbacks. Программа завершится вследствие нехватки памяти, так и не напечатая на экране 'A' or 'B'.

2. Есть ли способ определить наличие цикла во время вызова perform? Есть ли способ предотвратить появление такого цикла с помощью add-dependency?

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

    augment class Task {
        has Bool $!started = False;

        method perform() {
            if $!started++ && !$!done {
                die "Cycle detected, aborting";
            }

            unless $!done {
                .perform() for @!dependencies;
                &!callback();
                $!done = True;
            }
        }
    }

Еще один способ избежать циклических вызовов - это во время вызова метода add-dependency проверять добавляемые объекты на предмет присутствия их в зависимостях уже добавленных объектов ( собственно это и есть причина циклических вызовов). Данное решение потребует создание вспомогательного метода depends-on, который проверяет находится ли указанная задача в зависимостях напрямую или транзитивно. Обратите внимание как используются » и [||], чтобы код обхода зависимостей получился эффективным и лаконичным:

    augment class Task {
        method depends-on(Task $some-task) {
            $some-task === any(@!dependencies)
            [||] @!dependencies».depends-on($some-task)
        }

        method add-dependency(Task $dependency) {
            if $dependency.depends-on(self) {
                warn 'Cannot add that task, since it would introduce a cycle.';
                return;
            }
            push @!dependencies, $dependency;
        }
    }

3. Каким образом объект Task может выполнит зависимые задачи параллельно ? (Подумайте как можно избежать коллизий в "бриллиантовых зависимостях" (Пер. - не встречал ранее такого выражения.)), когда две разных зависимых задачи требуют выполнения одной). Ответ: Включение параллельного выполнения просто: достаточно заменить вызов метода .perform() для @!dependencies; на @!dependencies».perform(). Однако в таком случае могут возникнуть "гонки" I(race conditions) в случае наличия бриллиантовых зависимостей, когда задача A запускает одновременно B и C, а они в свою очередь запускают D (D запускается дважды). Решение этой проблемы такое же как и в случае с циклическими вызовами в вопросе 2 - ввести атрибут $!started. Заметьте, что в случае параллельного выполнения, вызов die в одной из задач может прервать исполнение других.

    augment class Task {
        has Bool $!started = False;

        method perform() {
            unless $!started++ {
                @!dependencies».perform();
                &!callback();
                $!done = True;
            }
        }
    }

Candidates can specify more complex signatures:

    multi to-json($d where {!defined $d}) { 'null' }

This candidate adds two new twists. It contains no type definition, in which case the type of the parameter defaults to Any, the root of the normal branch of the type hierarchy. More interestingly, the where {!defined $d} clause is a constraint, which defines a so-called subset type. This candidate will match only some values of the type Any--those where the value is undefined.

Whenever the compiler performs a type check on the parameter $d, it first checks the nominal type (here, Any). If that check succeeds, it calls the code block. The entire type check can only succeed if the code block returns a true value.

The curly braces for the constraint can contain arbitrary code. You can abuse this to count how often a type check occurs:

    my $counter = 0;

    multi a(Int $x)  { };
    multi a($x)      { }
    multi a($x where { $counter++; True }) { };

    a(3);
    say $counter;       # says B<0>
    a('str');
    say $counter;       # says B<2>

This code defines three multis, one of which increases a counter whenever its where clause executes. Any Perl 6 compiler is free to optimize away type checks it knows will succeed. In the current Rakudo implementation, the second line with say will print a higher number than the first.

In the first call of a(3), the nominal types alone already determine the best candidate match, so the where block never executes and the first $counter output is always 0.

The output after the second call is at least 1. The compiler has to execute the where-block at least once to check if the third candidate is the best match, but the specification does not require the minimal possible number of runs. This is illustrated in the second $counter output. The specific implementation used to run this test actually executes the where-block twice. Keep in mind that the number of times the subtype checks blocks execute is specific to any particular implementation of Perl 6.

One candidate remains from the JSON example:

    multi to-json($d) {
        die "Can't serialize an object of type " ~ $d.WHAT.perl
    }

With no explicit type or constraint on the parameter $d, its type defaults to Any--and thus it matches any passed object. The body of this function complains that it doesn't know what to do with the argument. This works for the example, because JSON's specification covers only a few basic structures.

The declaration and intent may seem simple at first, but look closer. This final candidate matches not only objects for which there is no candidate defined, but it can match for all objects, including Int, Bool, Num. A call like to-json(2) has two matching candidates--Int and Any.

If you run that code, you'll discover that the Int candidate gets called. Because Int is a type that conforms to Any, it is a narrower match for an integer. Given two types A and B, where A conforms to B (A ~~ B, in Perl 6 code), an object which conforms to A does so more narrowly than to B. In the case of multi dispatch, the narrowest match always wins.

A successfully evaluated constraint makes a match narrower than a similar signature without a constraint. In the case of:

    multi to-json($d) { ... }
    multi to-json($d where {!defined $d}) { ... }

... an undefined value dispatches to the second candidate.

However, a matching constraint always contributes less to narrowness than a more specific match in the nominal type.

    TODO: Better example

    multi a(Any $x where { $x > 0 }) { 'Constraint'   }
    multi a(Int $x)                  { 'Nominal type' }

    say a(3), ' wins';       # says B<Nominal type wins>

This restriction allows a clever compiler optimization: it can sort all candidates by narrowness once to find the candidate with the best matching signature by examining nominal type constraints. These are far cheaper to check than constraint checks. Constraint checking occurs next, then the compiler considers the nominal types of candidates.

With some trickery it is possible to get an object which conforms to a built-in type (Num, for example) but which is also an undefined value. In this case the candidate that is specific to Num wins, because the nominal type check is narrower than the where {!defined $d} constraint.

Candidate signatures may contain any number of positional and named arguments, both explicit and slurpy. However only positional parameters contribute to the narrowness of a match:

    # RAKUDO has problems with an enum here,
    # it answers with "Player One wins\nDraw\nDraw"
    # using separate classes would fix that,
    # but is not as pretty.
    enum Symbol <Rock Paper Scissors>;
    multi wins(Scissors $, Paper    $) { +1 }
    multi wins(Paper    $, Rock     $) { +1 }
    multi wins(Rock     $, Scissors $) { +1 }
    multi wins(::T      $, T        $) {  0 }
    multi wins(         $,          $) { -1 }

    sub play($a, $b) {
        given wins($a, $b) {
            when +1 { say 'Player One wins' }
            when  0 { say 'Draw'            }
            when -1 { say 'Player Two wins' }
        }
    }

    play(Scissors, Paper);
    play(Paper,    Paper);
    play(Rock,     Paper);

This example demonstrates how multiple dispatch can encapsulate all of the rules of a popular game. Both players independently select a symbol (rock, paper, or scissors). Scissors win against paper, paper wraps rock, and scissors can't cut rock, but go blunt trying. If both players select the same item, it's a draw.

The code creates a type for each possible symbol by declaring an enumerated type, or enum. For each combination of chosen symbols for which Player One wins there's a candidate of the form:

    multi wins(Scissors $, Paper $) { +1 }

Because the bodies of the subs here do not use the parameters, there's no reason to force the programmer to name them; they're anonymous parameters. A single $ in a signature identifies an anonymous scalar variable.

The fourth candidate, multi wins(::T $, T $) { 0 } uses ::T, which is a type capture (similar to generics or templates in other programming languages). It binds the nominal type of the first argument to T, which can then act as a type constraint. If you pass a Rock as the first argument, T acts as an alias for Rock inside the rest of the signature and the body of the routine. The signature (::T $, T $) will bind only two objects of the same type, or where the second is of a subtype of the first.

In this game, that fourth candidate matches only for two objects of the same type. The routine returns 0 to indicate a draw.

The final candidate is a fallback for the cases not covered yet--every case in which Player Two wins.

If the (Scissors, Paper) candidate matches the supplied argument list, it is two steps narrower than the (Any, Any) fallback, because both Scissors and Paper are direct subtypes of Any, so both contribute one step.

If the (::T, T) candidate matches, the type capture in the first parameter does not contribute any narrowness--it is not a constraint, after all. However T is a constraint for the second parameter which accounts for as many steps of narrowness as the number of inheritance steps between T and Any. Passing two Rocks means that ::T, T is one step narrower than Any, Any. A possible candidate:

    multi wins(Rock $, Rock $) {
        say "Two rocks? What is this, 20,000 years ago?"
    }

... would win against (::T, T).

Traits can apply implicit constraints:

    multi swap($a is rw, $b is rw) {
        ($a, $b) = ($b, $a);
    }

This routine exchanges the contents of its two arguments. It must bind the two arguments as rw--both readable and writable. Calling the swap routine with an immutable value (for example a number literal) will fail.

The built-in function substr can not only extract parts of strings, but also modify them:

    # substr(String, Start, Length)
    say substr('Perl 5', 0, 4);         # prints B<Perl>

    my $p = 'Perl 5';
    # substr(String, Start, Length, Substitution)
    substr($p, 6, 1, '6');
    # now $p contains the string B<Perl 6>

You already know that the three-argument version and the four-argument version have different candidates: the latter binds its first argument as rw:

    multi substr($str, $start = 0, $length = *) { ... }
    multi substr($str is rw, $start, $length, $substitution) { ... }

This is also an example of candidates with different arity (number of expected arguments). This is seldom really necessary, because it is often a better alternative to make parameters optional. Cases where an arbitrary number of arguments are allowed are handled with slurpy parameters instead:

    sub mean(*@values) {
        ([+] @values) / @values;
    }

An earlier chapter showed how to use nested signatures to look deeper into data structures and extract parts of them. In the context of multiple dispatch, nested signatures take on a second task: they act as constraints to distinguish between the candidates. This means that it is possible to dispatch based upon the shape of a data structure. This brings Perl 6 a lot of the expressive power provided by pattern matching in various functional languages.

Some algorithms have very tidy and natural expressions with this feature, especially those which recurse to a simple base case. Consider quicksort. The base case is that of the empty list, which trivially sorts to the empty list. A Perl 6 version might be:

    multi quicksort([]) { () }

The [] declares an empty nested signature for the first positional parameter. Additionally, it requires that the first positional parameter be an indexable item--anything that would match the @ sigil. The signature will only match if the multi has a single parameter which is an empty list.

The other case is a list which contains at least one value--the pivot--and possibly other values to partition according to the pivot. The rest of quicksort is a couple of recursive calls to sort both partitions:

    multi quicksort([$pivot, *@rest]) {
        my @before = @rest.grep({ $_ <= $pivot });
        my @after  = @rest.grep({ $_ >  $pivot });

        return quicksort(@before), $pivot, quicksort(@after);
    }

You have two options to write multi subs: either you start every candidate with multi sub ... or multi ..., or you declare once and for all that the compiler shall view every sub of a given name as a multi candidate. Do the latter by installing a proto routine:

    proto to-json($) { ... }       # literal ... here

    # automatically a multi
    sub to-json(Bool $d) { $d ?? 'true' !! 'false' }

Nearly all Perl 6 built-in functions and operators export a proto definition, which prevents accidental overriding of built-ins^[6].

Each multi dispatch builds a list of candidates, all of which satisfy the nominal type constraints. For a normal sub or method call, the dispatcher invokes the first candidate which passes any additional constraint checks.

A routine can choose to delegate its work to other candidates in that list. The callsame primitive calls the next candidate, passing along the arguments received. The callwith primitive calls the next candidate with different (and provided) arguments. After the called routine has done its work, the callee can continue its work.

If there's no further work to do, the routine can decide to hand control completely to the next candidate by calling nextsame or nextwith. The former reuses the argument list and the latter allows the use of a different argument list. This delegation is common in object destructors, where each subclass may perform some cleanup for its own particular data. After it finishes its work, it can delegate to its parent class meethod by calling nextsame.

Previous chapters have explained classes and grammars. A role is another type of package. Like classes and grammars, a role can contain methods (including named regexes) and attributes. However, a role cannot stand on its own; you cannot instantiate a role. To use a role, you must incorporate it into an object, class, or grammar.

In other object systems, classes perform two tasks. They represent entities in the system, providing models from which to create instances. They also provide a mechanism for code re-use. These two tasks contradict each other to some degree. For optimal re-use, classes should be small, but in order to represent a complex entity with many behaviors, classes tend to grow large. Large projects written in such systems often have complex interactions and workarounds for classes which want to reuse code but do not want to take on additional unnecessary capabilities.

Perl 6 classes retain the responsibility for modeling and managing instances. Roles handle the task of code reuse. A role contains the methods and attributes required to provide a named, reusable unit of behavior. Building a class out of roles uses a safe mechanism called flattening composition. You may also apply a role to an individual object. Both of these design techniques appear in the example code.

Some roles--parametric roles--allow the use of specific customizations to change how they provide the features they provide. This helps Perl 6 provide generic programming, along the lines of generics in C# and Java, or templates in C++.

Look at the KarmaKeeper class declaration. The body is empty; the class defines no attributes or methods of its own. The class inherits from IRCBot, using the is trait modifier--something familiar from earlier chapters--but it also uses the does trait modifier to compose two roles into the class.

The process of role composition is simple. Perl takes the attributes and methods defined in each role and copies them into the class. After composition, the class appears as if those attributes and methods had been declared in the class's declaration itself. This is part of the flattening property: after composing a role into the class, the roles in and of themselves are only important when querying the class to determine if it performs the role. Querying the methods of the KarmaKeeper class through introspection will report that the class has both a process method and an on-message multi method.

If this were all that roles provided, they'd have few advantages over inheritance or mixins. Roles get much more interesting in the case of a conflict. Consider the class definition:

    class MyBot is IRCBot does AnswerToAll does AnswerIfTalkedTo {}

Both the AnswerToAll and AnswerIfTalkedTo roles provide a method named process. Even though they share a name, the methods perform semantically different--and conflicting--behaviors. The role composer will produce a compile-time error about this conflict, asking the programmer to provide a resolution.

Multiple inheritance and mixin mechanisms rarely provide this degree of conflict resolution. In those situations, the order of inheritance or mixin decides which method wins. All possible roles are equal in role composition.

What can you do if there is a conflict? In this case, it makes little sense to compose both of the roles into a class. The programmer here has made a mistake and should choose to compose only one role to provide the desired behavior. An alternative way to resolve a conflict is to write a method with the same name in the class body itself:

    class MyBot is IRCBot does AnswerToAll does AnswerIfTalkedTo {
        method process($raw-in) {
            # Do something sensible here...
        }
    }

If the role composer detects a method with the same name in the class body, it will then disregard all of the (possibly conflicting) ones from the roles. Put simply, methods in the class always supersede methods which a role may provide.

    class KarmaKeeper is IRCBot {
        does AnswerToAll;
        does KarmaTracking;
        does Oping;
    }

    self.*on-message($msg<sender>, $msg<message>)

    method bot-nick() { ... }

Class declarations frozen at compilation time are often sufficient, but sometimes it's useful to add new behaviors to individual objects. Perl 6 allows you to do so by applying roles to individual objects at runtime.

The example in this chapter uses this to give bots new abilities during their lifetimes. The Plugins role is at the heart of this. The signature of the method on-message captures the invocant into a variable $self marked rw, which indicates that the invocant may be modified. Inside the method, that happens:

    if %pluggables{$0} -> $plug-in {
        B<$self does $plug-in;>
        return "Loaded $0";
    }

Roles in Perl 6 are first-class entities, just like classes. You can pass roles around just like any other object. The %pluggables hash maps names of plug-ins to Role objects. The lookup inside on-message stores a Role in $plug-in. The does operator adds this role to $self--not the class of $self, but the instance itself. From this point on, $self now has all of the methods from the role, in addition to all of the ones that it had before. This does affect any other instances of the same class; only this one instance has changed.

So far every regex could match anywhere within a string. Often it is useful to limit the match to the start or end of a string or line or to word boundaries. A single caret ^ anchors the regex to the start of the string and a dollar sign $ to the end. m/ ^a / matches strings beginning with an a, and m/ ^ a $ / matches strings that consist only of an a.

Regex can be very useful for extracting information too. Surrounding part of a regex with round brackets (aka parentheses) (...) makes Perl capture the string it matches. The string matched by the first group of parentheses is available in $/[0], the second in $/[1], etc. $/ acts as an array containing the captures from each parentheses group:

    my $str = 'Germany was reunited on 1990-10-03, peacefully';

    if $str ~~ m/ (\d**4) \- (\d\d) \- (\d\d) / {
        say 'Year:  ', $/[0];
        say 'Month: ', $/[1];
        say 'Day:   ', $/[2];
        # usage as an array:
        say $/.join('-');       # prints 1990-10-03
    }

If you quantify a capture, the corresponding entry in the match object is a list of other match objects:

    my $ingredients = 'eggs, milk, sugar and flour';

    if $ingredients ~~ m/(\w+) ** [\,\s*] \s* 'and' \s* (\w+)/ {
        say 'list: ', $/[0].join(' | ');
        say 'end:  ', $/[1];
    }

This prints:

    list: eggs | milk | sugar
    end:  flour

The first capture, (\w+), was quantified, so $/[0] contains a list of words. The code calls .join to turn it into a string. Regardless of how many times the first capture matches (and how many elements are in $/[0]), the second capture is still available in $/[1].

As a shortcut, $/[0] is also available under the name $0, $/[1] as $1, and so on. These aliases are also available inside the regex. This allows you to write a regex that detects that common error of duplicated words, just like the example at the beginning of this chapter:

    my $s = 'the quick brown fox jumped over the the lazy dog';

    if $s ~~ m/ « (\w+) \W+ $0 » / {
        say "Found '$0' twice in a row";
    }

The regex first anchors to a left word boundary with « so that it doesn't match partial duplication of words. Next, the regex captures a word ((\w+)), followed by at least one non-word character \W+. This implies a right word boundary, so there is no need to use an explicit boundary. Then it matches the previous capture followed by a right word boundary.

Without the first word boundary anchor, the regex would for example match strand and beach or lathe the table leg. Without the last word boundary anchor it would also match the theory.

You can declare regexes just like subroutines--and even name them. Suppose you found the example at the beginning of this chapter useful and want to make it available easily. Suppose also you want to extend it to handle contractions such as doesn't or isn't:

    my regex word { \w+ [ \' \w+]? }
    my regex dup  { « <word=&word> \W+ $<word> » }

    if $s ~~ m/ <dup=&dup> / {
        say "Found '{$<dup><word>}' twice in a row";
    }

This code introduces a regex named word, which matches at least one word character, optionally followed by a single quote. Another regex called dup (short for duplicate) contains a word boundary anchor.

Within a regex, the syntax <&word> locates the regex word within the current lexical scope and matches against the regex. The <name=&regex> syntax creates a capture named name, which records what &regex matched in the match object.

In this example, dup calls the word regex, then matches at least one non-word character, and then matches the same string as previously matched by the regex word. It ends with another word boundary. The syntax for this backreference is a dollar sign followed by the name of the capture in angle brackets^[12].

Within the if block, $<dup> is short for $/{'dup'}. It accesses the match object that the regex dup produced. dup also has a subrule called word. The match object produced from that call is accessible as $<dup><word>.

Named regexes make it easy to organize complex regexes by building them up from smaller pieces.

The previous example to match a list of words was:

    m/(\w+) ** [\,\s*] \s* 'and' \s* (\w+)/

This works, but the repeated "I don't care about whitespace" units are clumsy. The desire to allow whitespace anywhere in a string is common. Perl 6 regexes allow this through the use of the :sigspace modifier (shortened to :s):

    my $ingredients = 'eggs, milk, sugar and flour';

    if $ingredients ~~ m/:s ( \w+ ) ** \,'and' (\w+)/ {
        say 'list: ', $/[0].join(' | ');
        say 'end:  ', $/[1];
    }

This modifier allows optional whitespace in the text wherever there one or more whitespace characters appears in the pattern. It's even a bit cleverer than that: between two word characters whitespace is mandatory. The regex does not match the string eggs, milk, sugarandflour.

The :ignorecase or :i modifier makes the regex insensitive to upper and lower case, so m/ :i perl / matches perl, PerL, and PERL (though who names a programming language in all uppercase letters?)

In the course of matching a regex against a string, the regex engine may reach a point where an alternation has matched a particular branch or a quantifier has greedily matched all it can, but the final portion of the regex fails to match. In this case, the regex engine backs up and attempts to match another alternative or matches one fewer character of the quantified portion to see if the overall regex succeeds. This process of failing and trying again is backtracking.

When matching m/\w+ 'en'/ against the string oxen, the \w+ group first matches the whole string because of the greediness of +, but then the en literal at the end can't match anything. \w+ gives up one character to match oxe. en still can't match, so the \w+ group again gives up one character and now matches ox. The en literal can now match the last two characters of the string, and the overall match succeeds.

While backtracking is often useful and convenient, it can also be slow and confusing. A colon : switches off backtracking for the previous quantifier or alternation. m/ \w+: 'en'/ can never match any string, because the \w+ always eats up all word characters and never releases them.

The :ratchet modifier disables backtracking for a whole regex, which is often desirable in a small regex called often from other regexes. The duplicate word search regex had to anchor the regex to word boundaries, because \w+ would allow matching only part of a word. Disabling backtracking makes \w+ always match a full word:

    my regex word { :ratchet \w+ [ \' \w+]? }
    my regex dup  { <word=&word> \W+ $<word> }

    # no match, doesn't match the 'and'
    # in 'strand' without backtracking
    'strand and beach' ~~ m/<&dup>/

The effect of :ratchet applies only to the regex in which it appears. The outer regex will still backtrack, so it can retry the regex word at a different staring position.

The regex { :ratchet ... } pattern is common that it has its own shortcut: token { ... }. An idiomatic duplicate word searcher might be:

    my B<token> word { \w+ [ \' \w+]? }
    my regex dup   { <word> \W+ $<word> }

A token with the :sigspace modifier is a rule:

    my rule wordlist { <word> ** \, 'and' <word> }

Regexes are also good for data manipulation. The subst method matches a regex against a string. With subst matches, it substitutes the matched portion of the string its the second operand:

    my $spacey = 'with    many  superfluous   spaces';

    say $spacey.subst(rx/ \s+ /, ' ', :g);
    # output: with many superfluous spaces

By default, subst performs a single match and stops. The :g modifier tells the substitution to work globally to replace every possible match.

Note the use of rx/ ... / rather than m/ ... / to construct the regex. The former constructs a regex object. The latter constructs the regex object and immediately matches it against the topic variable $_. Using m/ ... / in the call to subst creates a match object and passes it as the first argument, rather than the regex itself.

Sometimes you want to call other regexes, but don't want them to capture the matched text. When parsing a programming language you might discard whitespace characters and comments. You can achieve that by calling the regex as <.otherrule>.

If you use the :sigspace modifier, every continuous piece of whitespace calls the built-in rule <.ws>. This use of a rule rather than a character class allows you to define your own version of whitespace characters (see ).

Sometimes you just want to peek ahead to check if the next characters fulfill some properties without actually consuming them. This is common in substitutions. In normal English text, you always place a whitespace after a comma. If somebody forgets to add that whitespace, a regex can clean up after the lazy writer:

    my $str = 'milk,flour,sugar and eggs';
    say $str.subst(/',' <?before \w>/, ', ',  :g);
    # output: milk, flour, sugar and eggs

The word character after the comma is not part of the match, because it is in a look-ahead introduced by <?before ... >. The leading question mark indicates an zero-width assertion: a rule that never consumes characters from the matched string. You can turn any call to a subrule into an zero width assertion. The built-in token <alpha> matches an alphabetic character, so you can rewrite this example as:

    say $str.subst(/',' <?alpha>/, ', ',  :g);

An leading exclamation mark negates the meaning, such that the lookahead must not find the regex fragment. Another variant is:

    say $str.subst(/',' <!space>/, ', ',  :g);

You can also look behind to assert that the string only matches after another regex fragment. This assertion is <?after>. You can write the equivalent of many built-in anchors with look-ahead and look-behind assertions, though they won't be as efficient.

    sub line-and-column(Match $m) {
        my $line   = ($m.orig.substr(0, $m.from).split("\n")).elems;
        # RAKUDO workaround for RT #70003, $m.orig.rindex(...) directly fails
        my $column = $m.from - ('' ~ $m.orig).rindex("\n", $m.from);
        $line, $column;
    }

    my $s = "the quick\nbrown fox jumped\nover the the lazy dog";

    my token word { \w+ [ \' \w+]? }
    my regex dup { <word> \W+ $<word> }

    if $s ~~ m/ <dup> / {
        my ($line, $column) = line-and-column($/);
        say "Found '{$<dup><word>}' twice in a row";
        say "at line $line, column $column";
    }

    # output:
    # Found 'the' twice in a row
    # at line 3, column 6

Every regex match returns an object of type Match. In boolean context, a match object returns True for successful matches and False for failed ones. Most properties are only interesting after successful matches.

The orig method returns the string that was matched against. The from and to methods return the positions of the start and end points of the match.

In the previous example, the line-and-column function determines the line number in which the match occurred by extracting the string up to the match position ($m.orig.substr(0, $m.from)), splitting it by newlines, and counting the elements. It calculates the column by searching backwards from the match position and calculating the difference to the match position.

Using a match object as an array yields access to the positional captures. Using it as a hash reveals the named captures. In the previous example, $<dup> is a shortcut for $/<dup> or $/{ 'dup' }. These captures are again Match objects, so match objects are really trees of matches.

The caps method returns all captures, named and positional, in the order in which their matched text appears in the source string. The return value is a list of Pair objects, the keys of which are the names or numbers of the capture and the values the corresponding Match objects.

    if 'abc' ~~ m/(.) <alpha> (.) / {
        for $/.caps {
            say .key, ' => ', .value;

        }
    }

    # Output:
    # 0 => a
    # alpha => b
    # 1 => c

In this case the captures occur in the same order as they are in the regex, but quantifiers can change that. Even so, $/.caps follows the ordering of the string, not of the regex. Any parts of the string which match but not as part of captures will not appear in the values that caps returns.

To access the non-captured parts too, use $/.chunks instead. It returns both the captured and the non-captured part of the matched string, in the same format as caps, but with a tilde ~ as key. If there are no overlapping captures (as occurs from look-around assertions), the concatenation of all the pair values that chunks returns is the same as the matched part of the string.

The similarity of grammars to classes goes deeper than storing regexes in a namespace as a class might store methods. You can inherit from and extend grammars, mix roles into them, and take advantage of polymorphism. In fact, a grammar is a class which by default inherits from Grammar instead of Any.

Suppose you want to enhance the JSON grammar to allow single-line C++ or JavaScript comments, which begin with // and continue until the end of the line. The simplest enhancement is to allow such a comment in any place where whitespace is valid.

However, JSON::Tiny::Grammar only implicitly matches whitespace through the use of rules, which are like tokens but with the :sigspace modifier enabled. Implicit whitespace is matched with the inherited regex <ws>, so the simplest approach to enable single- line comments is to override that named regex:

    grammar JSON::Tiny::Grammar::WithComments
        is JSON::Tiny::Grammar {

        token ws {
            \s* [ '//' \N* \n ]?
        }
    }

    my $tester = '{
        "country":  "Austria",
        "cities": [ "Wien", "Salzburg", "Innsbruck" ],
        "population": 8353243 // data from 2009-01
    }';

    if JSON::Tiny::Grammar::WithComments.parse($tester) {
        say "It's valid (modified) JSON";
    }

The first two lines introduce a grammar that inherits from JSON::Tiny::Grammar. As subclasses inherit methods from superclasses, so any grammar rule not present in the derived grammar will come from its base grammar.

In this minimal JSON grammar, whitespace is never mandatory, so ws can match nothing at all. After optional spaces, two slashes '//' introduce a comment, after which must follow an arbitrary number of non- newline characters, and then a newline. In prose, the comment starts with '//' and extends to the rest of the line.

Inherited grammars may also add variants to proto tokens:

    grammar JSON::ExtendedNumeric is JSON::Tiny::Grammar  {
        token value:sym<nan> { <sym> }
        token value:sym<inf> { <[+-]>? <sym> }
    }

In this grammar, a call to <value> matches either one of the newly added alternatives, or any of the old alternatives from the parent grammar JSON::Tiny::Grammar. Such extensibility is difficult to achieve with ordinary, | delimited alternatives.

The parse method of a grammar returns a Match object through which you can access all the relevant information of the match. Named regex that match within the grammar may be accessed via the Match object similar to a hash where the keys are the regex names and the values are the Match object that represents that part of the overall regex match. Similarly, portions of the match that are captured with parentheses are available as positional elements of the Match object (as if it were an array).

Once you have the Match object, what can you do with it? You could recursively traverse this object and create data structures based on what you find or execute code. An alternative solution exists: action methods.

    class JSON::Tiny::Actions {
        method TOP($/)      { make $/.values.[0].ast }
        method object($/)   { make $<pairlist>.ast.hash }
        method pairlist($/) { make $<pair>».ast }
        method pair($/)     { make $<string>.ast => $<value>.ast }
        method array($/)    { make [$<value>».ast] }
        method string($/)   { make join '', $/.caps>>.value>>.ast }

        # TODO: make that
        # make +$/
        # once prefix:<+> is sufficiently polymorphic
        method value:sym<number>($/) { make eval $/ }
        method value:sym<string>($/) { make $<string>.ast }
        method value:sym<true>  ($/) { make Bool::True  }
        method value:sym<false> ($/) { make Bool::False }
        method value:sym<null>  ($/) { make Any }
        method value:sym<object>($/) { make $<object>.ast }
        method value:sym<array> ($/) { make $<array>.ast }

        method str($/)               { make ~$/ }

        method str_escape($/) {
            if $<xdigit> {
                make chr(:16($<xdigit>.join));
            } else {
                my %h = '\\' => "\\",
                        'n'  => "\n",
                        't'  => "\t",
                        'f'  => "\f",
                        'r'  => "\r";
                make %h{$/};
            }
        }
    }

    my $actions = JSON::Tiny::Actions.new();
    JSON::Tiny::Grammar.parse($str, :$actions);

This example passes an actions object to the grammar's parse method. Whenever the grammar engine finishes parsing a regex, it calls a method on the actions object with the same name as the current regex. If no such method exists, the grammar engine moves along. If a method does exist, the grammar engine passes the current match object as a positional argument.

Each match object has a slot called ast (short for abstract syntax tree) for a payload object. This slot can hold a custom data structure that you create from the action methods. Calling make $thing in an action method sets the ast attribute of the current match object to $thing.

In the case of the JSON parser, the payload is the data structure that the JSON string represents. For each matching rule, the grammar engine calls an action method to populate the ast slot of the match object. This process transforms the match tree into a different tree--in this case, the actual JSON tree.

Although the rules and action methods live in different namespaces (and in a real-world project probably even in separate files), here they are adjacent to demonstrate their correspondence:

    rule TOP        { ^ [ <object> | <array> ]$ }
    method TOP($/)  { make $/.values.[0].ast }

The TOP rule has an alternation with two branches, object and array. Both have a named capture. $/.values returns a list of all captures, here either the object or the array capture.

The action method takes the AST attached to the match object of that sub capture, and promotes it as its own AST by calling make.

    rule object        { '{' ~ '}' <pairlist>  }
    method object($/)  { make $<pairlist>.ast.hash }

The reduction method for object extracts the AST of the pairlist submatch and turns it into a hash by calling its hash method.

    rule pairlist       { [ <pair> ** [ \, ] ]? }
    method pairlist($/) { make $<pair>».ast; }

The pairlist rule matches multiple comma-separated pairs. The reduction method calls the .ast method on each matched pair and installs the result list in its own AST.

    rule pair       { <string> ':' <value> }
    method pair($/) { make $<string>.ast => $<value>.ast }

A pair consists of a string key and a value, so the action method constructs a Perl 6 pair with the => operator.

The other action methods work the same way. They transform the information they extract from the match object into native Perl 6 data structures, and call make to set those native structures as their own ASTs.

The action methods that belong to a proto token are parametric in the same way as the alternative:

    token value:sym<null>        { <sym>    };
    method value:sym<null>($/)   { make Any }

    token value:sym<object>      { <object> };
    method value:sym<object>($/) { make $<object>.ast }

When a <value> call matches, the action method with the same parametrization as the matching alternative executes.

Sometimes coercion is transparent. Perl 6 has several numeric types which can intermix freely--such as subtracting a floating point value from an integer, as 123 - 12.1e1.

The most important types are:

The following operators are available for all number types:

Most mathematical functions are available both as methods and functions, so you can write both (-5).abs and abs(-5).

The trigonometric functions sin, cos, tan, asin, acos, atan, sec, cosec, cotan, asec, acosec, acotan, sinh, cosh, tanh, asinh, acosh, atanh, sech, cosech, cotanh, asech, acosech and acotanh work in units of radians by default. You may specify the unit with an argument of Degrees, Gradians or Circles. For example, 180.sin(Degrees) is approximately 0.

Strings stored as Str are sequences of characters, independent of character encoding. The Buf type is available for storing binary data. The encode method converts a Str to Buf. decode goes the other direction.

The following operations are available for strings:

A Boolean value is either True or False. Any value can coerce to a boolean in boolean context. The rules for deciding if a value is true or false depend on the type of the value:

Constructs such as if automatically evaluate their conditions in boolean context. You can force an explicit boolean context by putting a ? in front of an expression. The ! prefix negates the boolean value.

    my $num = 5;

    # implicit boolean context
    if $num { say "True" }

    # explicit boolean context
    my $bool    = ?$num;

    # negated boolean context
    my $not_num = !$num;

Одна из особенностей формата Pod - его структура. На первый взгляд, есть некоторое внешнее сходство между документацией, написанной в формате Perl5 POD, и текстом в формате Perl6 Pod. Это потому, что различия лежат в основе синтаксической структуры обоих форматов.

Основным элементом формата Pod (как и в perl5 POD) являются директивы, используемые для определения границ блоков Pod, описания конфигурационной информации (=config) и т.д. Каждая директива начинается с символа "равно" (=) в начале строки.

Примеры директив:

    =config head2  :like<head1> :formatted<I>
    =begin pod
    =end pod

Содержимое документа состоит из одного или нескольких блоков. Каждый блок Pod может быть определен в виде трех равнозначных формах:

Все три формы соответственно представлены на рисунке.

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

В perl5 POD блок документации начинается с первой встреченной директивы и закачивается директивой =cut. Например:

   =head1 test head
    
   Some text
    
   =cut

Таким образом получается, что структура Perl5 POD состоит из одного типа блока с указанными правилами определения границ, где директива =cut является неотъемлемой частью и служит признаком завершения блока. После этой директивы, обработчик (parser) Perl5 POD переключается в "молчаливый" режим пока не встретит следующий символ = в начале строки.

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

Новые 3 формы определения блока Pod стали эволюционным развитием Perlpod Pod от POD (Plain Old Documentation).

Основной структурной единицей нового диалекта Pod является блок документации. Он может быть представлен в виде 3 равнозначных форм:

  =begin BLOCK_TYPE  OPTIONAL CONFIG INFO
  =                  OPTIONAL EXTRA CONFIG INFO
  BLOCK CONTENTS
  =end BLOCK_TYPE

    =begin table  :caption<Table of Contents>
        Constants           1
        Variables           10
        Subroutines         33
        Everything else     57
    =end table

    =begin Name  :required
    =            :width(50)
    The applicant's full name
    =end Name

    =begin Contact  :optional
    The applicant's contact details
    =end Contact

    =for BLOCK_TYPE  OPTIONAL CONFIG INFO
    =                OPTIONAL EXTRA CONFIG INFO
    BLOCK DATA

    =for table  :caption<Table of Contents>
        Constants           1
        Variables           10
        Subroutines         33
        Everything else     57

    =for Name  :required
    =          :width(50)
    The applicant's full name

    =for Contact  :optional   
    The applicant's contact details

    =BLOCK_TYPE  BLOCK DATA
    MORE BLOCK DATA

    =table
        Constants           1
        Variables           10
        Subroutines         33
        Everything else     57

    =Name     The applicant's full name
    =Contact  The applicant's contact details

 my $declared_thing;   #= Pod here until end of line
 sub declared_thing () {   #=[ Pod here
                              until matching
                               closing bracket
                             ]
         ...
  }

Равнозначность стилевых блоков

Описанные выше типы блоков одинаково представлены во внутренней структуре документа. То есть если имя типа блока - параграф (=para), то он остается параграфом независимо от формы его описания.

Практически это означает, что приведенные ниже блоки:

 =begin para
 Text
 =end para

 =for para text

 =para text

при конвертации в html будут преобразованы в один и тот же текст:

    <p>text</p>

Если тип блока таблица, то она останется ею в любом случае.

Pod резервирует несколько стандартных параметров для использования во встроенных типах блоков. Список этих параметров следующий:

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

Например:

    Ягоды:
    =for item :numbered
    Клубника
    =for item :numbered
    Земляника
    =for item :numbered
    Черника

Будет выглядеть как :

Ягоды:

Примененное к заголовкам это свойство добавляет номер уровня.

Например вместо:

    =begin para
    B<I<
    Warning: Do not immerse in water. Do not expose to bright light.
    Do not feed after midnight.
    >>
    =end para

можно использовать:

    =begin para :formatted<B I>
    Warning: Do not immerse in water. Do not expose to bright light.
    Do not feed after midnight.
    =end para

Данные формы во внутреннем представлении почти эквивалентны. Единственное различие: во втором случае свойство :formatted остается в атрибутах объекта блока.

Коды форматирования, указанные в свойстве :formatted, дополняют уже примененные к блоку.

Параметр :like может быть применен к любому блоку, а также к директиве =config.

Пример:

    =config head1 :numbered
    =config head2  :like<head1> :formatted<I>

В этом примере, благодаря :like, блоки заголовков второго уровня =head2 становятся нумерованными.

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

Любой блок может быть вложенным (nested). Для этого достаточно указать атрибут блока :nested:

    =begin para :nested
        We are all of us in the gutter,
        but some of us are looking at the stars!
    =end para

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

    =begin para :nested
        We are all of us in the gutter,
        but some of us are looking at the stars!
    =end para
    =begin para :nested(2)
            -- Oscar Wilde
    =end para

Формат Pod предоставляет блок =nested, который означает, что все его содержимое должно быть вложенным:

    =begin nested
    We are all of us in the gutter,
    but some of us are looking at the stars!
        =begin nested
        -- Oscar Wilde
        =end nested
    =end nested

Блоки вложенности =nested могут содержать любое количество блоков, включая неявные параграфы и блоки кода. Следует отметить, что физические отступы блоков не играют роли при определении их уровня вложенности. Предидущий пример может быть переписан с учетом этого следующим образом:

    =begin nested
    We are all of us in the gutter,
    but some of us are looking at the stars!
    =begin nested
    -- Oscar Wilde
    =end nested
    =end nested

Списки в Pod представлены в виде групп, следующих друг за другом блоков =item. Каких либо специальных директив-"контейнеров" или разделителей для определения границ списков нет. Например:

     The seven suspects are:

     =item  Happy
     =item  Dopey
     =item  Sleepy
     =item  Bashful
     =item  Sneezy
     =item  Grumpy
     =item  Keyser Soze

Элементы списка имеют неявный уровень вложенности:

Списки могут быть многоуровневыми. Каждый уровень указывается с помощью блоков =item1, =item2, =item3 и т.д. В этом смысле блок =item является синонимом =item1. Например:

     =item1  Animal
     =item2     Vertebrate
     =item2     Invertebrate

     =item1  Phase
     =item2     Solid
     =item2     Liquid
     =item2     Gas
     =item2     Chocolate

Результат следующий:

Обработчики Pod должны выдавать предупреждающее сообщение в случаях, когда разность между уровнями вложенности соседствующих блоков больше 1. Например, если за блоком =item1 следует блок =item3.

Блоки =item не могут содержать вложенные списки. Это значит, что даже элементы с более низким уровнем вложенности не могут присутствовать внутри =item более высокого уровня.

    =comment НЕВЕРНО...
    =begin item1          --------------
    The choices are:                    |
    =item2 Liberty        ==< Level 2   |==<  Level 1
    =item2 Death          ==< Level 2   |
    =item2 Beer           ==< Level 2   |
    =end item1            --------------

    =comment ПРАВИЛЬНО...
    =begin item1          ---------------
    The choices are:                     |==< Level 1
    =end item1            ---------------
    =item2 Liberty        ==================< Level 2
    =item2 Death          ==================< Level 2
    =item2 Beer           ==================< Level 2

     =for item1 :numbered
     Visito

     =for item2 :numbered
     Veni

     =for item2 :numbered
     Vidi

     =for item2 :numbered
     Vici

     =item1  # Visito
     =item2     # Veni
     =item2     # Vidi
     =item2     # Vici

    =item V<#> introduces a comment

    =for item :!numbered
    # introduces a comment

    The options are:

    =item1 # Liberty
    =item1 # Death
    =item1 # Beer

    The tools are:

    =item1 # Revolution
    =item1 # Deep-fried peanut butter sandwich
    =item1 # Keg

     =for item1
     # Retreat to remote Himalayan monastery

     =for item1
     # Learn the hidden mysteries of space and time

     I<????>

     =for item1 :continued
     # Prophet!

    =item1 Reading
    =item2 Writing
    =item3 'Rithmetic

     Let's consider two common proverbs:

     =begin item :numbered
     I<The rain in Spain falls mainly on the plain.>

     This is a common myth and an unconscionable slur on the Spanish
     people, the majority of whom are extremely attractive.
     =end item

     =begin item :numbered
     I<The early bird gets the worm.>

     In deciding whether to become an early riser, it is worth
     considering whether you would actually enjoy annelids
     for breakfast.
     =end item

     As you can see, folk wisdom is often of dubious value.

    =defn  MAD
    Affected with a high degree of intellectual independence.

    =defn  MEEKNESS
    Uncommon patience in planning a revenge that is worth while.

    =defn
    MORAL
    Conforming to a local and mutable standard of right.
    Having the quality of general expediency.

    =for defn :numbered
    SELFISH
    Devoid of consideration for the selfishness of others.

    =defn # SUCCESS
    The one unpardonable sin against one's fellows.

С помощью директивы =aliases можно определить ограниченный лексической областью видимости псевдоним для: части Pod текста, определения (мета) объекта в коде или даже куска программного кода. Данные псевдонимы используются в тексте Pod благодаря коду форматирования A<>.

Директива =alias является такой же фундаментальной, как =begin или =for. Она не может быть представлена в виде разграниченного (delimited) или параграфного (paragraph) блока.

Существует два вида псевдонимов: псевдонимы для макросов и контекстуальные (contextual) псевдонимы. Для обоих этих видов существует лексическая область видимости, ограниченная текущим Pod блоком.

    =alias PROGNAME    Earl Irradiatem Evermore
    =alias VENDOR      4D Kingdoms
    =alias TERMS_URLS  =item L<http://www.4dk.com/eie>
    =                  =item L<http://www.4dk.co.uk/eie.io/>
    =                  =item L<http://www.fordecay.ch/canttouchthis>

    The use of A<PROGNAME> is subject to the terms and conditions
    laid out by A<VENDOR>, as specified at:

        A<TERMS_URL>

    The use of Earl Irradiatem Evermore is subject to the terms and
    conditions laid out by 4D Kingdoms Inc, as specified at:
     
        =item L<http://www.4dk.com/eie>
        =item L<http://www.4dk.co.uk/eie.io/>
        =item L<http://www.fordecay.ch/canttouchthis>

    =alias PROGNAME    Count Krunchem Constantly
    =alias VENDOR      Last Chance Receivers Intl
    =alias TERMS_URLS  L<http://www.c11.com/generic_conditions>

    # This is actual code...

    sub hash_function ($key)
    =alias HASHCODE
    {
        my $hash = 0;
        for $key.split("") -> $char {
            $hash = $hash*33 + $char.ord;
        }
        return $hash;
    }

    =begin pod
    An ancient (but fast) hashing algorithm is used:

        =begin code :allow<A>
        A<HASHCODE>
        =end code

    =end pod

 An ancient (but fast) hashing algorithm is used:

    my $hash = 0;
    for $key.split("") -> $char {
        $hash *= 33;
        $hash += $char.ord;
    }
    return $hash;

    =alias CLASSNAME
    class Database::Handle {
        =alias ATTR
        has IO $!handle;

        =alias OPEN
        my Bool method open ($filename?) {...}

        =alias DEFNAME
        constant Str DEFAULT_FILENAME = 'db.log';

        =for para
            Note that the A<OPEN.name> method of class A<CLASSNAME>
            stores the resulting low-level database handle
            in its private A<ATTR.name> attribute. By default,
            handles are opened to the file "A<DEFNAME>".

    }

Pod предоставляет три кода форматирования для отметки уровня значимости текста:

Пример использования:

Текст может быть отмечен минимальным (подчеркнутым), основным (курсивом) и фундаментальным (жирным) уровнями значимости.

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

Это следующие блоки:

Оба эти блока отображаются как есть, с сохранением форматирования и пробелов.

Подобно блокам =code , оба =input и =output блоки имеют неявный уровень вложения (level of nesting, т.е. уровни вложения - предмет отдельного разговора, т.к. описаны они в спецификации вскользь и неопределенно). Блоки ввода-вывода, подобно блокам =code, отображаются с использованием шрифта фиксированной ширины (fixed width font), однако желательно, чтобы все три блока в документе отображались различными сочетаниями шрифт/ширина. Например : код - обычным шрифтом с засечками (regular serifed), ввод с клавиатуры - жирным sans-serif, а =output - обычным sans-serif.

В отличии от блока =code, оба блока допускают коды форматирования в их содержимом. В Pod имеются коды форматирования ( K - ввод с клавиатуры и T - вывод на терминал) указывающие на ввод или вывод данных. Данная особенность привносит элемент интерактивности в документы, и делает возможным визуально демонстрировать процесс ввода данных и вывод результатов.

Пример демонстрации действий пользователя представлен ниже:

 =begin output
   Name:    Baracus, B.A.
   Rank:    Sgt
   Serial:  1PTDF007

   Do you want additional personnel details? K<y>

   Height:  180cm/5'11"
   Weight:  104kg/230lb
   Age:     49

   Print? K<n>
 =end output

Содержимое кода X<> является элементом индекса. Текст внутри X отображается в итоговом тексте, а также используется как элемент индекса:

    An X<array> is an ordered list of scalars indexed by number,
    starting with 0. A X<hash> is an unordered collection of scalar
    values indexed by their associated string key.

Возможно точное указание индексируемого текста и элемента индекса. Для этого используется вертикальная черта:

    An X<array|arrays> is an ordered list of scalars indexed by number,
    starting with 0. A X<hash|hashes> is an unordered collection of
    scalar values indexed by their associated string key.

В таком случае, элемент индекса располагается после черты. Элементы индекса чувствительны к регистру. В примере "array" - индексируемый текст, а "arrays" - элемент индекса.

Для указания индексных уровней используется запятая:

    An X<array|arrays, definition of> is an ordered list of scalars
    indexed by number, starting with 0. A X<hash|hashes, definition of>
    is an unordered collection of scalar values indexed by their
    associated string key.

Можно указывать двое или больше элементов индекса для одного участка индексируемого текста. В качестве разделителя используется символ "точка с запятой":

    A X<hash|hashes, definition of; associative arrays>
    is an unordered collection of scalar values indexed by their
    associated string key.

Индексируемый текст может быть пустым. Элемент индекса будет в таком случае "нулевой ширины":

    X<|puns, deliberate>This is called the "Orcish Manoeuvre"
    because you "OR" the "cache".

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

Для вставки в Pod документ кодовой точки (code point) Unicode или ссылки на HTML5 символ, укажите необходимую сущность (entity), используя код форматирования .

Если содержит число, оно интерпретируется как десятичное значение требуемой Unicode кодовой точки. Например:

  Perl 6 makes considerable use of « and ».

Можно также использовать явно двоичные, восьмеричные, десятичные и шестнадцатеричные числа (используя нотацию Perl 6 для указания формата представления):

    Perl 6 makes considerable use of « and ».
    Perl 6 makes considerable use of « and ».
    Perl 6 makes considerable use of « and ».
    Perl 6 makes considerable use of « and ». 

Если содержимое отлично от числа, оно интерпретируется как имя символа Unicode ( которое всегда в верхнем регистре ) или именованная ссылка на символ HTML5. Например:

   Perl 6 makes considerable use of 《
    and 》.

что эквивалентно:

    Perl 6 makes considerable use of  and .

Множество последовательно расположенных сущностей ( в любом формате представления) могут быть указаны в одном коде , разделенных точкой с запятой:

 Perl 6 makes considerable use of 《».

Примеры

Get ⌨ I<(keyboard)> and type € I<(Euro)>.

Do : ①,②,③,④,⑤.

Snow : ❄ ❅ ❆

• Get ⌨ (keyboard) and type € (Euro).

• Do : ①,②,③,④,⑤.

• Snow : ❄ ❅ ❆

В качестве источника я использовал следующие таблицы Unicode.

Содержимое кода N<> является встроенным примечанием. Например:

    Use a C<for> loop instead.N<The Perl 6 C<for> loop is far more
    powerful than its Perl 5 predecessor.> Preferably with an explicit
    iterator variable.

Трансляторы Pod ^[14] могут отображать содержимое примечаний разными способами: как сноски, как пояснения в конце книги или главы, как боковые панели с текстом, как всплывающие окна или подсказки, как разворачивающиеся элементы, и т.д. Однако они никогда не отображаются обычным текстом. Таким образом, предыдущий пример может быть отображен как:

Use a for loop instead. Preferably with an explicit iterator
variable.

и далее:

Footnotes
 The Perl 6 for loop is far more powerful than its Perl 5
predecessor.

Код форматирования D<> указывает, что содержащийся внутри текст является определением термина. При этом окружающий текст разъясняет данный термин. Данный код представляется собой строковый эквивалент блока =defn. Например:

    There ensued a terrible moment of D<coyotus interruptus>: a brief
    suspension of the effects of gravity, accompanied by a sudden
    to-the-camera realisation of imminent downwards acceleration.

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

    A D<formatting code|formatting codes;formatters> provides a way
    to add inline mark-up to a piece of text.

Определения обычно отображаются курсивом или отмечены тэгами <dfn>...</dfn>. На определения часто ссылаются из других частей гипертекстовых документов, где встречаются указанные термины (или любые из соответствующих синонимов).

Код форматирования Z<> означает, что его содержимое является комментарием нулевой длины и не отображается. Например:

    The "exeunt" command Z<Think about renaming this command?> is used
    to quit all applications.

В формате Perl 5 POD код Z<> широко использовался для разбиения последовательности кодов разметки на составные части, чтобы избежать их интерпретации:

    In Perl 5 POD, the ZZ<><> code was widely used to break up text
    that would otherwise be considered mark-up.

Данный прием продолжает работать, однако, достичь результата сейчас легче благодаря "дословному" (verbatim) коду форматирования:

    In Perl 5 POD, the  V<Z<>>  code was widely used to break up text
    that would otherwise be considered mark-up.

Кроме того C<> также обрабатывает свое содержимое как "дословный" текст, что позволяет исключить необходимость в коде V<>:

    In Perl 5 POD, the C<Z<>> code was widely used to break up text
    that would otherwise be considered mark-up.

Код форматирования Z<> является эквивалентом блока =comment.

    class Widget is Bauble
    {
        has $.things; #= a collection of other stuff
        #={ Z<CONFIDENTIAL>
            This variable needs to be replaced for political reasons
        }
    }

Любой текст, заключенный в код S<> форматируется как обычно, сохраняя при этом пробельные символы ( в том числе символ новой строки ). Эти символы интерпретируются как неразрывные пробелы ( кроме новой строки). Например:

    The emergency signal is: S<
    dot dot dot   dash dash dash   dot dot dot>.

Будет отформатирован следующим образом:

вместо:

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

Стандартные семантические блоки:

    =NAME
    =VERSION
    =SYNOPSIS
    =DESCRIPTION
    =USAGE
    =INTERFACE 
    =METHOD
    =SUBROUTINE
    =OPTION
    =DIAGNOSTIC
    =ERROR
    =WARNING
    =DEPENDENCY
    =BUG
    =SEEALSO
    =ACKNOWLEDGEMENT
    =AUTHOR
    =COPYRIGHT
    =DISCLAIMER 
    =LICENCE
    =LICENSE
    =TITLE
    =SECTION
    =CHAPTER
    =APPENDIX
    =TOC
    =INDEX
    =FOREWORD
    =SUMMARY

Для указанных имен зарегистрированы соответствующие имена во множественном числе.

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

Pod предоставляет коды форматирования для указания примеров ввода, вывода, кода и мета синтаксиса: