Предисловие

В Perl 6 появились не только новые регулярные выражения, но и более мощный встроенный в язык инструмент — грамматики.

Сразу нужно оговориться, что регулярные выражения Perl 6 официально называются регексами (regex) — теперь это не разговорное сокращение, а полное название. В контексте грамматик более употребительными окажутся термины правило и токен.

В этой серии публикаций речь будет идти о том, как создать простую грамматику для обработки запросов типа «20 EUR in USD». Регексы, которые потребуется по ходу дела, будут прокомментированы по ходу же дела.

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

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

Второй момент — результат сопоставления строки с регексом (или разбор в соответствии с грамматикой) всегда возвращает объект типа Match, обычно доступный в переменной $/.

Часть I. Первый тест

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

use v6;
 
grammar TestGrammar {
    rule TOP {
        ^ <sign>? <digit>+ $
    }
 
    token sign {
        '-' | '+'
    }
 
    token digit {
        <[0..9]>
    }
}
 
while my $string = prompt('> ') {
    if TestGrammar.parse($string) {
        say "OK";
    }
    else {
        say "Failed";
    }
}

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

grammar TestGrammar {
    . . .
}

Внутри блока находятся несколько вложенных блоков, предваренных ключевыми словами rule и token. По сути это именованные регулярные выражения, которые и составляют грамматику.

Отличия между rule и token только в том, что для токенов не действует откат. То есть токен должен совпасть максимально длинно, и если он захватил символы до полного совпадения, то попытки переосмыслить часть совпавших символов не произойдет. Кроме того, в пределах правила и токена по-разному обрабатываются пробелы на входе — токен должен быть единой последовательностью, в точности описанной в грамматике, в правиле же допускаются пробелы между его частями.

Первое правило, которое стоит в начале процесса разбора, должно называться TOP.

rule TOP {
    ^ <sign>? <digit>+ $
}

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

Метасимволы ^ и $ привязывают правило, соответственно, к началу и концу строки. Перевод строки, если он был, совпадет с $. А если не было, $ все равно успешно совпадет с концом строки.

Имена в угловых скобках — токены, которые определены далее в грамматике. После каждого из них в правиле TOP стоят метасимволы, определяющие, сколько раз токены могут встретиться. Токен sign (после которого стоит ?) должен совпасть либо один раз, либо отсутствовать в строке. Токен digit (после него стоит +) может многократно повторяться, но обязан присутствовать хотя бы один раз.

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

token sign {
    '-' | '+'
}

Наконец, токен digit описывает, что такое цифра. В нашем определении цифра — символ из класса <[0..9]>. Синтаксис для записи символьных классов — квадратные скобки внутри угловых (а угловые скобки, как видно из предыдущих примеров, используются для того, чтобы упомянуть одно правило внутри другого). Синтаксис для диапазона символов (две точки) совпадает с тем, что используется в самом Perl 6.

token digit {
    <[0..9]>
}

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

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

while my $string = prompt('> ') {
    if TestGrammar.parse($string) {
        say "OK";
    }
    else {
        say "Failed";
    }
}

Цикл while выполняет блок кода до тех пор, пока истинно его условие (в Perl 6 скобки для условия не нужны, хотя по-прежнему нужны для блока кода). В нашем случае условие содержит и объявление переменной my $string, и вызов функции prompt('> ').

Функция prompt выводит на печать свой аргумент — строку '> ' — и ожидает, пока пользователь не введет строку и нажмет Enter. Полученный текст попадает в скаляр $string.

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

if TestGrammar.parse($string) {
    . . . 
}
else {
    . . .
}

В зависимости от исхода анализа строки выводится сообщение «OK» или «Failed».

Запускаем программу и пробуем ввести разные строки:

> 42
OK
> -42
OK
> NaN
Failed
> +36
OK
> 36.6
Failed

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

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

Привет! Меня зовут Габор Сабо. Это четвертая часть обучающих материалов о Perl 6. На этот раз я расскажу про файлы. Остальные презентации можно найти по ссылкам на странице szabgab.com/perl6.html.

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

use v6;
 
my $content = slurp "text.txt";
say $content.chars;

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

Slurp читает все, включая переводы строк и все строки. Поэтому если распечатать переменную $content, напечатается все, что было в файле. Для презентации это слишком много, поэтому я вызову метод .chars, который напечатает число символов в этом файле.

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

423

Печатается число символов в файле.

Если же прочитать то же самое в массив, программисты Perl 5 могут подумать, что это считает файл построчно. Но в Perl 6 это не так.

use v6;
 
my @content = slurp "text.txt";
say @content.elems;
 
say @content[0].chars;

В Perl 6 slurp всегда читает весь файл в виде единственной строки, так что у массива будет только один элемент. Если вызвать метод .elems, увидим в результате один элемент в массиве, который содержит весь файл.

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

1
423

Чтобы в Perl 6 прочитать каждую строку отдельно, нужно использовать функцию lines.

use v6;
 
my @content = lines "text.txt";
say @content.elems;
 
say @content[0].chars;

Она так же получает имя файла, но возвращает содержимое построчно.

Выполнив программу, увидим, что в файле 12 строк, и в первой строке 39 символов.

12
39

Очевидно, и slurp, и lines бесполезны, если файл очень большой. В этих случаях мы хотим просматривать файлы строка за строкой, что-то с ними делать, и идти дальше. В этом случае в памяти будет только одна строка.

Вот как это делать:

use v6;
 
for lines "text.txt" -> $line {
    say $line.chars;
}

Здесь мы пользуемся циклом for, а внутри — опять функцией lines. В этом случае lines выполняется отложенно, то есть она будет читать строки одна за другой, и на каждой итерации помещать содержимое строки в скалярную переменную $line, а затем выполняется блок.

Сейчас в блоке мы вызываем на этой переменной метод .chars, печатая число символов в этой строке.

39
0
67
78
0
76
56
0
86
9
0
0

Видим, что в первой строке 39 символов, затем идет пустая строка, затем — 67 и так далее.

Кроме того, можно открыть файл и выполнить чтение из него.

use v6;
 
my $fh = open "text.txt";
 
my $first_line = $fh.get;
say $first_line;
 
for $fh.lines -> $line {
    say $line.chars;
}

Для этого используем функцию open. Она принимает имя файла и возвращает файловый дескриптор. С файлом можно делать разные действия, например, прочитать одну строку, используя метод .get:

my $first_line = $fh.get;

Он вернет одну строку, и мы можем ее распечатать.

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

for $fh.lines -> $line {
    say $line.chars;
}

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

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

Introduction to Perl 6 - part 4 - files
0
67
78
0
76
56
0
86
9
0
0

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

use v6;
 
my $fh = open "out.txt", :w;
$fh.say("text 3");
$fh.close;
 
say slurp "out.txt";

В этом случае мы также вызываем функцию open, передаем ей имя файла, в который собираемся записывать, а затем — параметр :w, сообщающий, что файл открывается для записи.

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

Возвращается файловый дескриптор, и затем на нем мы можем вызвать метод .say со строкой, и она напечатается в файл.

Например, если я заменю текст на "text 4" и выполню программу, появится новое содержимое:

text 4

Почему? Потому что после печати я вызвал метод .close. В Perl это не обязательно, но в некоторых случаях это важно, чтобы убедиться, что все записано в файл. Иначе Perl буферизирует вывод, а как только я закрыл файл, я смогу вызвать slurp, и он напечатает то, что мы видели.

Еще раз напомню, что остальные части вы можете найти по ссылке szabgab.com/perl6.html. Спасибо.

Привет! Меня зовут Габор Сабо. Это третья часть презентаций о Perl 6. На этот раз я расскажу про массивы и немного про диапазоны. Остальные презентации можно найти по ссылкам на странице szabgab.com/perl6.html.

Как вы помните из предыдущей презентации, мы создали массив из списка значений и прошлись по всем элементам в цикле for с переменной $n.

На этот раз код работает так же:

use v6;
 
my @people = <Foo 123 Bar 456 Moo 789 Foo 512>;
 
for @people -> $n {
    say $n;
}

Так что я могу выполнить файл, и массив распечатается:

Foo
123
Bar
456
Moo
789
Foo
512

Хорошо. Но как вы видите, это на самом-то деле похоже на пары: чье-то имя (Foo), и затем какое-то число (123), вероятно, телефонный номер этого человека.

Поэтому хочется пройтись в цикле по ним и брать сразу по два элемента. Пользователи Perl 5, возможно, предложат поместить все в хеш и затем пройтись по ключам и значениям. С этим возникнут проблемы.

Первая — мы еще не изучили хеши (в других языках они называются словарями). Другая — как только мы поместили значения в хеш, мы тут же потеряли их порядок, так что не сможем узнать, что Foo находится перед Bar. Во многих случаях это не имеет значения, но не всегда. Худшая же проблема в том, что Foo у нас появляется дважды. И если поместить все данные в хеш, то одно из них — скорее всего, первое — потеряется. Так что это неподходящее решение.

Нужен какой-то способ пройтись по всем парам, но без хешей.

Стандартный способ, которым обычно пользуются (он показан во втором примере), — перебор с помощью индекса $i и отбор пар расчетом нужных индексов элементов.

use v6;
 
my @people = <Foo 123 Bar 456 Moo 789 Foo 512>;
 
for 0 .. @people.elems/2 -> $i {
    say "@people[$i*2] -  @people[$i*2+1]";
}

Мы можем сделать это: взять массив, вызвать .elems — метод массива, возвращающий число элементов, разделить это надвое и получить диапазон, по которому мы должны пройтись в цикле. Посмотрим, как это работает.

Foo -  123
Bar -  456
Moo -  789
Foo -  512
Any() -  Any()

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

for 0 .. @people.elems/2 - 1 -> $i {

Это решит проблему:

Foo -  123
Bar -  456
Moo -  789
Foo -  512

Другой, лучший, способ — создать диапазон, исключив из него последнее значение:

for 0 ..^ @people.elems/2 -> $i {

Проблема решается так же хорошо:

Foo -  123
Bar -  456
Moo -  789
Foo -  512

Это неплохое решение, но в Perl 6 возможно поступить намного лучше.

В Perl 6 мы можем попросить цикл for выбирать по два элемента, указав две переменные после стрелочки:

use v6;
 
my @people = <Foo 123 Bar 456 Moo 789 Foo 512>;
 
for @people -> $name, $phone {
    say "$name - $phone";
}

Опять тот же результат, уже начинающий надоедать:

Foo - 123
Bar - 456
Moo - 789
Foo - 512

Вот так мы можем выбирать по два элемента. Точно так же можно выбирать три или больше — любое число элементов, которое требуется.

А что произойдет, если у нас два массива и мы хотим поэлементно объединить их?

Можно вновь применить индексы, а можно и оператор Perl 6 Z (от zip):

use v6;
 
my @names = <Foo Bar Moo Foo>;
my @phones = <123 456 789 512>;
 
for @names Z @phones -> $name, $phone {
    say "$name - $phone";
}

Оператор Z берет два массива, и в цикле мы получаем пары значений — одно из первого массива, другое из второго.

По-прежнему получаем тот же результат:

Foo - 123
Bar - 456
Moo - 789
Foo - 512

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

use v6;
 
my @names = <Foo Bar Moo Foo>;
my @phones = <123 456 789 512>;
 
for @names X @phones -> $name, $phone {
    say "$name - $phone";
}

Foo - 123
Foo - 456
Foo - 789
Foo - 512
Bar - 123
Bar - 456
Bar - 789
Bar - 512
Moo - 123
Moo - 456
Moo - 789
Moo - 512
Foo - 123
Foo - 456
Foo - 789
Foo - 512

Он объединяет каждый элемент первого массива с каждым элементом второго. Мы видим Foo со всеми числами, Bar со всеми числами, Moo со всеми и опять Foo со всеми числами (потому что Foo было дважды).

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

use v6;
 
for 1 .. 10 -> $n {
    $n;
}

Простой диапазон, от одного до десяти. Запускаем.

Напечатаются числа от одного до десяти:

1
2
3
4
5
6
7
8
9
10

Как мы уже видели, можно использовать ^, чтобы сказать, что мы не хотим включать последний элемент диапазона:

for 1 ..^ 10 -> $n {
    $n;
}

1
2
3
4
5
6
7
8
9

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

for 1 ^..^ 10 -> $n {
    $n;
}

2
3
4
5
6
7
8
9

Что делать, если нужен цикл сначала для единицы, а потом от трех до десяти? На самом деле, это не очень сложно, я могу написать единицу, и затем диапазон от трех до десяти:

for 1,3 .. 10 -> $n {
    $n;
}

Выполнив это, получим 1 и числа от 3 до 10:

1
3
4
5
6
7
8
9
10

Это не всегда то, что нужно. Чаще потребуются, например, 1, 3, 5, то есть, каждый второй элемент. В Perl 6 это просто, потому что нужно поставить еще одну точку, превращающую оператор диапазона (..) в оператор последовательности (...):

for 1,3 ... 10 -> $n {
    $n;
}

В этом случае Perl 6 попытается посмотреть на первые два элемента и понять, как нужно продолжать последовательность до правой границы:

1
3
5
7
9

Очевидно, 10 не попало в список; цикл закончился, когда была пройдена эта граница.

Хорошо, но здесь есть некоторые ограничения. Что будет, если я не знаю границы диапазона, а захочу идти бесконечно?

for 1 .. Inf -> $n {
    say $n;
}

Perl 6 сможет и это, но очевидно не остановится. Чтобы сделать пример полезным, потребуется некоторое условие выхода из цикла. Я напечатаю:

for 1 .. Inf -> $n {
    say $n;
    last if $n > 10;
}

1
2
3
4
5
6
7
8
9
10
11

Теперь я вновь могу запустить этот код, и цикл пройдет от 1 до 11, пока не удовлетворится условие. Очевидно, условие может быть и другим, не связанным с $n, лишь бы оно останавливало цикл.

То же самое, что мы сделали с Inf, можно сделать и со звездочкой. * — это оператор «whatever» в Perl 6.

for 1 .. * -> $n {
    say $n;
    last if $n > 10;
}

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

1
2
3
4
5
6
7
8
9
10
11

Опять же, можно воспользоваться той же идеей и создать диапазон от трех до «whatever».

for 1, 3 .. * -> $n {
    say $n;
    last if $n > 10;
}

Или можно создать последовательность 1, 3, 5 до какого-либо предела.

for 1, 3 ... * -> $n {
    say $n;
    last if $n > 10;
}

1
3
5
7
9
11

На сегодня это все. Спасибо.

Привет! Меня зовут Габор Сабо, и сейчас будет вторая часть презентаций о Perl 6. На этот раз я расскажу про массивы. Если вам интересны темы, связанные с Perl 6, посмотрите на ссылки на странице szabgab.com/perl6.html.

Рассмотрим первый пример.

use v6;
 
my @names = ("Foo", "Bar", "Moo");
 
say @names;

Как и в Perl 5, символ @ означает массивы. То есть здесь мы объявляем массив и помещаем в него три значения — три строки. Чтобы распечатать содержимое массива, достаточно напечатать say и имя массива.

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

eval slurp '01.p6'

FooBarMoo

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

Лучше всего — воспользоваться методом .perl на массиве:

say @names.perl;

Здесь возвращается строка, и если ее выполнить (через eval), то получится исходная структура данных.

["Foo", "Bar", "Moo"]

Действительно удобно для отладки.

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

say @names[1];

Если это выполнить, напечатается второй элемент.

Bar

Пользователи Perl 5 заметят, что сигил при этом не изменился. Это потому, что в Perl 6 сигилы не изменяются. Массив всегда будет сопровождаться символом @.

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

say @names[]

При выполнении опять получаем те же три значения:

FooBarMoo

Кроме того, в отличие от Perl 5, скобки вокруг массива не обязательны:

my @names = "Foo", "Bar", "Moo";

По-прежнему создается массив, и по-прежнему печатаются значения:

FooBarMoo

А что если мне захочется интерполировать массив?

use v6;
 
my @names = "Foo", "Bar", "Moo";
 
say "Hello @names how are you?";

Выполняем второй пример:

eval slurp '02.p6'

Hello @names how are you?

Как видите, @names оказывается на печати. В Perl 6 массивы автоматически не интерполируются. Чтобы этого добиться, нужно поставить квадратные скобки — тут они очень пригодятся.

say "Hello @names[] how are you?";

Hello Foo Bar Moo how are you?

На этот раз Perl понимает, что мы, на самом деле, имели в виду массив по имени @names, и вставляет все значения из массива внутрь строки, разделяя их пробелами.

Аналогично, я могу указать индекс, и проинтерполируется соответствующее значение:

say "Hello @names[1] how are you?";

Hello Bar how are you?

Существует и другой способ интерполировать значения: поставить вокруг переменной фигурные скобки:

say "Hello {@names} how are you?";

Выполнив, получим все три значения из массива:

Hello Foo Bar Moo how are you?

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

use v6;
 
my @names = "Foo", "Bar", "Moo";
 
say "Hello { join('; ', @names) } how are you?";

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

Выполняем этот вариант.

eval slurp '03.p6'

Hello Foo; Bar; Moo how are you?

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

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

use v6;
 
my @names = <Foo Bar Moo>;
 
say "Hello {@names} how are you?";

Это работает аналогично qw в Perl 5: из трех значений создается список из трех элементов.

На последнем примере посмотрим, как можно в цикле пройтись по элементам массива.

use v6;
 
my @names = <Foo Bar Moo>;
 
for @names -> $n {
   say $n;
}

Я воспользовался циклом for, он получает массив, а затем, после стрелочки, скаляр. Как видите, этот скаляр не обязательно объявлять с помощью my, потому что перл автоматически создаст его для нас внутри области видимости следующего блока, так что там не придется беспокоиться о $n.

В примере for пройдется по всем значениям в @names, помещая в $n Foo, потом Bar, потом Moo и печатая каждое из них.

Надеюсь, этот рассказ вам понравился, будет и продолжение. До свидания.