Perl 6

Хакатон про Perl 6

13 мая (в пятницу) в рамках конференции YAPC::Russia «May Perl — 4» + Perl Mova состоится хакатон, посвященный компилятору Perl 6 Rakudo. Мероприятие состоится в помещении центра «Цифровой октябрь» по адресу: Москва, Берсеневская набережная, 6. Карта проезда: digitaloctober.ru/contact.

Вход свободный. Начало в 10:00 (можно подтягиваться попозже).

Если вы собираетесь принять участие в хакатоне, приносите свой ноутбук, на котором установлен по крайней мере git.

hackathon, rakudo, yapc — 12 мая 2011

От Perl 5 к Perl 6 — введение

Perl 6 еще недостаточно документирован. Не удивительно, потому что (в отличие от спецификации) написание компилятора для Perl 6 представляется гораздо более приоритетной задачей, чем написание документации, ориентированной на пользователя.

От Perl 5 к Perl 6 — Строки, массивы, хеши

Perl 6 — почти как Perl 5, только лучше. Инструкции разделяются точками с запятыми. После последней инструкции в блоке или после закрывающей фигурной скобки в конце строки точка с запятой не обязательна. Имена переменных, как и раньше, начинаются с сигилов (например, $, @, %), и многие встроенные функции Perl 5 почти не были изменены в Perl 6.

Карл Мэсак про Ракудо

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

Интервью с Дамианом Конвеем

Конференция O’Reilly по программному обеспечению с открытым кодом, OSCON, столь же славится умными беседами в кулуарах и за обедами, сколько и семинарами, заседаниями и программными выступлениями. Терри Камерленго пригласил на ненавязчивую беседу Дамиана Конвея, автора «Perl Best Practices» и «Perl Hacks», чтобы узнать о его мыслях касательно самых разных тем, начиная с подробностей про Perl 6 и заканчивая тем, что по его мнению важно для следующего поколения ученых в области компьютерных наук.

Презентация про регексы и грамматики в Perl 6

grammar, regex — 21 сентября 2010

Потребление памяти в Rakudo

Мориц Ленц сообщает о том, что на своих экспериментах по расчету физических явлений он заметил существенное снижение объема памяти, потребляемого Rakudo.

Правки, устраняющие утечку памяти, — всего несколько строк, но зато теперь можно построить гигантскую картинку с изображением множества Мандельброта. Мориц показывает пример 1001×1001. Еще в мае более или менее быстро — и, что важнее, без падений — можно было построить картинку в 25 раз меньшую по площади.

speed, rakudo, leak, mandel — 26 августа 2010

perl6.ru

В интернете, за авторством Алексея Карманова, появился сайт perl6.su.

Важно не пропустить страницу Charte situs со ссылками на заметки по отдельным моментам синтаксиса Perl 6.

web, site — 22 августа 2010

Введение в грамматики Perl 6. Предисловие и часть I

Предисловие

В 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».

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

perl6 test.pl
> 42
OK
> -42
OK
> NaN
Failed
> +36
OK
> 36.6
Failed

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

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

grammar, rule, token, regex — 8 августа 2010

perl6doc.ru

На сайте perl6doc.ru появился первый полезный материал про Perl 6 — перевод документа Perl6::Perl5::Differences об отличиях Perl 6 и Perl 5:

Отличия между Perl 5 и Perl 6 (часть 1)

Динару Жамалиеву (perl5doc.ru, perl6doc.ru) респект и уважуха.

perl6doc, diff, perl5 — 2 августа 2010

Габор Сабо. Файлы в Perl 6

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


Привет! Меня зовут Габор Сабо. Это четвертая часть обучающих материалов о 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 и имя файла:

slurp eval '01.p6'
423

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

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

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

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

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

slurp eval '02.p6'
1
423

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

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

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

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

slurp eval '03.p6'
12
39

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

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

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

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

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

eval slurp '04.p6'
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;
}

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

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

eval slurp '05.p6'
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" и выполню программу, появится новое содержимое:

eval slurp '06.p6'
text 4

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

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

cast, open, slurp, lines, get, files — 1 августа 2010

Габор Сабо. Массивы и диапазоны в Perl 6

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


Привет! Меня зовут Габор Сабо. Это третья часть презентаций о 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;
}

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

eval slurp '01.p6'
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 — метод массива, возвращающий число элементов, разделить это надвое и получить диапазон, по которому мы должны пройтись в цикле. Посмотрим, как это работает.

eval slurp '02.p6'
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";
}
eval slurp '03.p6'

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

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 берет два массива, и в цикле мы получаем пары значений — одно из первого массива, другое из второго.

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

eval slurp '04.p6'
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";
}
eval slurp '04.p6'
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;
}

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

eval slurp '05.p6'

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

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 сможет и это, но очевидно не остановится. Чтобы сделать пример полезным, потребуется некоторое условие выхода из цикла. Я напечатаю:

last if $n > 10;
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

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

cast, array, range, series — 1 августа 2010

Perl 6 вышел в свет

Несколько дней назад Perl 6 исполнилось 10 лет. А 29 июля вышел в свет первый релиз компилятора Perl 6 Rakudo Star.

Rakudo Star (Rakudo *) — это отдельный дистрибутив Rakudo, который помимо компилятора включает в себя еще несколько компонент, в частности, набор полезных модулей и инструментов для работы с внешними библиотеками.

Подробности о релизе опубликованы на сайте проекта: rakudo.org/announce/rakudo-star/2010.07, а скачать дистрибутив можно на гитхабе: github.com/rakudo/star/downloads.


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

Разработчики сообщают, что компилятор содержит некоторое число ошибок и не обеспечивает слишком высокую скорость. Но — здесь надо сделать смысловое ударение — назначение нынешнего релиза никак не противоречит упомянутым недостаткам. Напротив, в отличие от регулярных дистрибутивов, выходивших в прошлые месяцы, Rakudo Star — максимально самодостаточен.


В состав Rakudo Star входят

компилятор Rakudo, релиз 31;

виртуальная машина Parrot, версия 2.6.0;

набор модулей и инструментов;

документация;

черновик книги про Perl 6 (на английском языке).

Планируется ежемесячное обновление этого комплекта.

Среди включенного в релиз:

Blizkost — библиотека для использования модулей Perl 5 в программах на Perl 6;

MiniDBI — простой интерфейс к базам данных;

Zavolaj — библиотека для вызова функций из C-библиотек;

SVG and SVG::Plot — модули для создания векторной графики;

HTTP::Daemon — простой HTTP-сервер;

XML::Writer — модуль для генерации XML;

YAML — модуль для печати объектов Perl 6 в виде YAML;

Term::ANSIColor — модуль для работы с терминалом :-);

Test::Mock — модуль, облегчающий тестирование с так называемыми мок-объектами (объектами-заглушками);

Math::Model — модуль для описания и запуска математических моделей;

Config::INI — парсер конфигурационных файлов;

File::Find — модуль для поиска файлов;

LWP::Simple — модуль для загрузки документов по сети.

Важно отметить, что с приходом Perl 6 сразу же встает вопрос о том, что модули, созданные на Perl 5, без существенных изменений их кода работать не смогут. Поэтому в этом списке фигурируют модули, одноименные существующим и доступными на CPAN, но переписанными на Perl 6. Во многих случаях это способствует улучшению кода модулей. Там, где требуется воспользоваться старыми модулями, предлагается обратиться к библиотекам Blizkost и Zavolaj.


На сегодня известно более полусотни проектов — модулей и отдельных приложений, написанных на Perl 6. Их перечень и ссылки на код собраны на сайте modules.perl6.org.

Название Rakudo образовано от японского словосочетания Rakudo-do («путь верблюда»). Будучи сокращенным до Rakudo, оно случайно совпало с японским словом рай.

В разработке Rakudo в разное время принимали участие 76 человек. Отдельные фрагменты были созданы в ходе хакмита на прошедшей этим летом в Киеве совместной конференции Perl Mova + YAPC::Russia.

Через неделю, в начале августа, на конференции YAPC::Europe 2010 в Пизе ожидается несколько докладов как о самом компиляторе, так и о языке Perl 6, а помимо этого запланированы учебные курсы, посвященные освоению языка.

rakudo, release — 29 июля 2010

Габор Сабо. Массивы в Perl 6

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


Привет! Меня зовут Габор Сабо, и сейчас будет вторая часть презентаций о 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 и печатая каждое из них.

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

array, for — 29 июля 2010

Дальнейшая навигация — по ключевым словам, через поиск или по календарю.

++   --   ..   activestate   advent   array   article   articles   bbc   book   bytes   chars   chr   class   code   compile   compiler   conway   default   demo   diff   массив   education   event   example   explanation   fast   fun   function   funding   future   given   grammar   grant   grep   hackathon   heredocs   if   internet   interpolation   invoke   japh   jnthn   kiev   leak   length   live   lol   lt   mandel   map   masak   match   moscow   november   NQP   скаляр   хеш   operator   operators   ord   p6c   parentheses   parrot   perl   perl5   perl510   perl6   perl6doc   perlmova2008   perlukr08   postfix   presentation   print   production   publications   pugs   qq:to   rakudo   range   regex   regexp   release   reverse   say   setup   sherman   site   snippet   speed   sprixel   state   switch   talk   ternary   TPF   tutorial   tv   unicode   uniq   UPW2008   v6   variable   web   what   when   windows   workshop   x   xx   yapc   yapceu07   yapceu08   ~  

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

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