Месяц: Февраль 2018

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

Задача — получить максимум возможных комбинаций, не потеряв смысл. Начнем с двух измерений: товар + услуга:

my $base = q:to/END/;
    окна
    пластиковые окна
    подоконники
    END

my $tags = q:to/END/;
    установка
    замер
    замер и установка
    изготовление
   END

Цитирующая конструкция q:to// здесь очень уместна — она позволяет не загромождать код кавычками. Теперь делим содержимое на отдельные строки и перемножаем результаты:

my @keywords = $base.lines X~ $tags.lines;

Метаоператор X совместно с оператором конкатенации ~ создает последовательность (Seq) строк, составленных из двух частей. Осталось только напечатать результат:

.say for @keywords;

Вот что получается в итоге:

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

Таким же образом можно легко добавить третье измерение (например, географию):

my $location = q:to/END/;

   москва
   московская область
  END

my @keywords = $base.lines X~ $tags.lines X~ $location.lines;
.say for @keywords;

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

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

Ура, это уже 50-я заметка в новом сезоне perl6.ru!

Сегодня мы поговорим об операторе флип-флоп, который похож на то, что было в пятом перле в виде трех точек. В Perl 6 этот оператор имеет вид ff.

Классический пример, на котором видно, как работает оператор, — пропуск Pod-документации:

say 'Hello, World!';

=begin pod
Documentation to the
"Hello, World!" program.
=end pod

say 'All done.';

Теперь берем перл и читаем программу построчно:

my @lines = './helloworld.pl'.IO.lines;

А затем проходимся в цикле по строкам и с помощью ff пропускаем блоки строк, начиная с открывающей строки =begin и заканчивая закрывающей =end:

for @lines {
    next if /^ '=' begin/ ff /^ '=' end/;
    .say;
}

На печати появляется код, очищенный от комментариев:

say 'Hello, World!';
say 'All done.';

В комплект Rakudo Star входит утилита — менеджер модулей zef. (Обратите внимание, что нужен именно Rakudo Star, а не просто компилятор Rakudo Perl 6 — в последнем случае и саму утилиту надо будет установить отдельно.)

Интерфейс довольно простой.

Установка модуля

$ zef install YAML

Далее все происходит автоматически:

===> Searching for: YAML
===> Searching for missing dependencies: TestML
===> Testing: TestML
=== A Basic TestML File ===
=== TestML with no data section ===
=== The Simplest TestML Test That Could Possibly Fail! ===
===> Testing [OK] for TestML
===> Testing: YAML
=== Test Dumping Perl 6 Data Objects to YAML ===
=== Failing Tests For People to Hack On ===
=== Various String Quoting ===
===> Testing [OK] for YAML
===> Installing: TestML
===> Installing: YAML

Удаление модуля

$ zef uninstall YAML

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

Информация о модуле

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

- Info for: YAML
- Identity: YAML
- Recommended By: Zef::Repository::LocalCache
Author:	 Ingy döt Net <ingy@cpan.org>
Description:	 YAML Ain’t Markup Language
License:	 Artistic-2.0
Source-url:	 git://github.com/perl6-community-modules/yaml-pm6.git
Provides: 2 modules
Depends: 1 items

Другие команды

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

Да, как же без алгоритма Sleep Sort?! Он должен быть аналогом «Hello, World!» для языков, умеющих делать параллельные вычисления. Итак, Sleep Sort на Perl 6.

my @data = 12, 4, 7, 5, 8, 1, 2;
await gather for @data -> $d {
    take start {
        sleep $d / 10;
        say $d;
    }
}

На каждый элемент данных создается отдельный поток, который ждет $d / 10 секунд и печатает число. Можно попробовать поделить и на большее число, но при этом возможно состояние гонки между потоками.

Сочетание await, gather и take позволяет дождаться все потоки и только потом завершить основную программу.

Запускаем программу, она печатает отсортированные числа:

$ perl6 sleep-sort.pl 
1
2
4
5
7
8
12

Для сортировки хеша в Perl 6 желательно знать, что такое placeholder variable. Как только эта концепция становится понятна, писать условие сортировки становится крайне просто.

Например, создадим хеш с расстояниями до разных городов от Москвы:

my %distance = 
    Владимир    => 185,
    Волгоград   => 1000,
    Калининград => 1227,
    Мурманск    => 1895,
    Новосибирск => 3550;

Теперь задача найти отсортировать элементы по увеличению расстояния.

say %distance.sort({$^a.value <=> $^b.value});

В общем-то, готово. Программа печатает то что надо:

(Владимир => 185 Волгоград => 1000 Калининград => 1227 
Архангельск => 1261 Астрахань => 1411 Мурманск => 1895 
Новосибирск => 3550)

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

Во-первых, переменные $^a и $^b — это плейсхолдеры, которые являются аргументами анонимного блока и сортируются по алфавиту. То есть с тем же успехом их можно было бы назвать $^x и $^y или $^var1 и $^var2.

Во-вторых, внутри этих переменных оказываются объекты типа Pair, который содержит поля key и value:

say %distance.sort({
    say $^a.key ~ ', ' ~ $^a.value ~ ' vs. ' ~ 
        $^b.key ~ ', ' ~ $^b.value;
    $^a.value <=> $^b.value
});

Таким способом мы сможем увидеть, какие пары получает метод сортировки:

Владимир, 185 vs. Новосибирск, 3550
Калининград, 1227 vs. Волгоград, 1000
Мурманск, 1895 vs. Астрахань, 1411
Владимир, 185 vs. Волгоград, 1000
Новосибирск, 3550 vs. Волгоград, 1000
Новосибирск, 3550 vs. Калининград, 1227
Астрахань, 1411 vs. Архангельск, 1261
Владимир, 185 vs. Архангельск, 1261
Волгоград, 1000 vs. Архангельск, 1261
Калининград, 1227 vs. Архангельск, 1261
Новосибирск, 3550 vs. Архангельск, 1261
Новосибирск, 3550 vs. Астрахань, 1411
Новосибирск, 3550 vs. Мурманск, 1895

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

say %distance.sort( -> $город1, $город2 {
    $город1.value <=> $город2.value
});

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

my @names = <alpha beta gamma>;
.say for @names;

Вы должны сами определиться с тем, ставить ли пробелы после открывающей и перед закрывающей скобкой. Часто можно видеть вот такой вариант:

my @names = < alpha beta gamma >;

В этом случае в массив попадут ровно те же три элемента.

Perl 6 считает разделителем между отдельными элементами все пробельные символы (whitespace), поэтому данные могут содержать, например, дефисы или точки:

my @nums = < . - 10 20.30 -40 >;

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

my @nums = < . - 10 20.30 -40 >;
for @nums {
    say "{$_.^name} $_";
}

Программа печатает следующее:

Str .
Str -
IntStr 10
RatStr 20.30
IntStr -40

Комментарии (ни обычные, ни embedded) внутри цитирующих скобок не работают. Возьмем программу:

my @data = <
    # comment?
    data_load 
>;
.say for @data;

В массиве окажется три элемента:

#
comment?
data_load

Вчера в группе Perl 6 на Фейсбуке Solomon Foster показал вот такой пример:

my @x = FatRat.new(1, 1), 
        -> $x { $x - ($x ** 2 - $N) / (2 * $x) } ... *;

В этом коде в одну строку реализован численный метод вычисления квадратного корня (методом Ньютона).

Давайте возьмем какое-то понятное число $N и посмотрим значение его корня на десятой итерации:

10.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000114617269858815597676188906948935679812072077815172636665039841545242611088386175405939458945274038752495996921868425893616324912131911758516481924280284021811361729487444582731688466773998426538733 . . .

Я показал только часть результата, в реальности цифр еще пять раз по столько же.

Что здесь примечательного?

Во-первых, тип FatRat — это дроби с произвольно большими числителем и знаменателем. Если использовать Rat, то мы довольно быстро придем к обычным числам с плавающей точкой.

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

В Perl 6 есть метаоператор Z, который объединяет два списка как застежка на молнии, по очереди перемежая элементы. Мы, возможно, рассмотрим его как-нибудь отдельно, но сегодня я хочу показать, как этот оператор магически транспонирует матрицу.

Берем двумерную матрицу:

my @matrixA = [1, 2],
              [3, 4];

Если хочется, можно поставить еще одни скобки:

my @matrixA = [[1, 2],
               [3, 4]];

И теперь в одно действие транспонируем:

my @matrixB = [Z] @matrixA;

Метаоператор Z здесь поставлен внутрь оператора редукции. Вуаля, матрица транспонировалась:

[(1 3) (2 4)]

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

sub f($a, @b, $c) {
    say "a = $a";
    say "b = @b[]";
    say "c = $c";
}

my @arr = <5 7 9>;
f(10, @arr, 20);

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

a = 10
b = 5 7 9
c = 20

Очень удобно, если сравнивать с Perl 5.

Но теперь возникает другой вопрос: а как передать переменное число скалярных величин так, чтобы они все оказались в одном массиве? Ответ: с помощью звездочки, которая создает так называемый slurpy-параметр.

sub g(*@data) {
    say @data;
}

g(3, 5, 7);

Эта программа работает правильно:

[3 5 7]

А вот если не поставить звездочку, то возникнет ошибка, поскольку ожидается один массив, а получены три скаляра:

===SORRY!=== Error while compiling sub-slurpy.pl
Calling g(Int, Int, Int) will never work with declared signature (@data)
at sub-slurpy.pl:5
------> <BOL>⏏g(3, 5, 7);