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

Возьмем простой пример. Если целое число четное, то я не хочу иметь дела с этой подпрограммой. В Perl 5 вы бы написали что-то похожее на это:

sub very_odd
{
    my $odd = shift;
    unless ($odd % 2)
    {
        return undef;
    }
    # Process the odd number here.
}

В Perl 6 это может быть упрощено:

sub very_odd(Int $odd where {$odd % 2})
{
    # Process the odd number here
}

При попытке вызова very_odd с четным числом вы получите сообщение об ошибке. Не волнуйтесь, хотя вы можете использовать возможности мультифункций чтобы дать даже числам возможность проявить себя… может быть. ;)

multi sub very_odd(Int $odd where {$odd % 2})
{
    # Process the odd number here
}
multi sub very_odd(Int $odd) { return Bool::False; }

Эти ограничения могут быть полезны при сочетании с методом .comb. Что же такое .comb? Для тех, кто расчесывает свои волосы: вы обычно пользуетесь расческой, чтобы уложить отдельные волоски. Для тех, кто любит использовать .split все как раз наоборот. Этот простой фрагмент кода должен продемонстрировать как работает .comb:

say "Perl 6 Advent".comb(/<alpha>/).join('|');
say "Perl 6 Advent".comb(/<alpha>+/).join('|');

Регулярные выражения, скорее всего, будут открыты в другой день, но быстрый взгляд не будет болезненным. Первая строка будет выводить «P|e|r|l|A|d|v|e|n|t»: берется каждый буквенный символ и помещается во временный массив. Затем он соединяется с символом вертикальной черты. Вторая строка аналогична, только она захватывает столько букв, сколько сможет, отсюда результат «Perl|Advent».

Однако, сила .comb намного больше. После того как вы «расчесали» что хотели, вы можете управлять «волосками». Если у вас есть определенный набор шестнадцатеричных ASCII символов, вы можете использовать гипероператоры для преобразования каждого кусочка в ASCII эквивалент!

say "5065726C36".comb(/<xdigit>**2/)».fmt("0x%s")».chr
# Outputs "Perl6"

Помните, это Perl. Существует много способов сделать это. ☺

Со всеми подарками, что были представлены сегодня, я дам вам задачу. С помощью Kayl Hasselbacher, я смог сделать достойную версию древнего шифра Цезаря при помощи ограничений, .comb, и старого доброго .map:

use v6;

sub rotate_one( Str $c where { $c.chars == 1 }, Int $n ) {
    return $c if $c !~~ /<alpha>/;
    my $out = $c.ord + $n;
    $out -= 26 if $out > ($c eq $c.uc ?? 'Z'.ord !! 'z'.ord);
    return $out.chr;
}

sub rotate(Str $s where {$s.chars}, Int $n = 3)
{
    return ($s.comb.map: { rotate_one( $_, $n % 26 ) }).join( '' );
}

die "Usage:\n$*PROGRAM_NAME string number_for_rotations" unless @*ARGS == 2;

my Str $mess = @*ARGS[0];
my Int $rotate = @*ARGS[1].Int;

say qq|"$mess" rotated $rotate characters gives "{rotate($mess,$rotate)}".|;

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

© Оригинальная статья.

Похожие статьи

• День 7: Циклы для пользы и развлечения
• День 6: Входя в Гиперпространство
• День 5: Метаоператоры
• День 4: Тестирование
• День 3: статические типы и мульти-функции

В Perl 6 все изменилось.

В настоящее время для итерации по спискам используется исключительно for. foreach исчез, а C-подобные циклы обрабатываются новым ключевым словом loop. Сегодня мы не будем это обсуждать, но мы собираемся сосредоточиться на новом цикле for, который в сочетании с другими языковыми особенностями Perl 6 предоставляет чрезвычайно гибкую и мощную конструкцию.

Давайте рассмотрим обычный случай.

for 1, 2, 3, 4 { .say }

Здесь сразу заметны некоторые вещи в синтакисе. Нет скобок списка конструкций, которые распространяются на весь Perl 6. В общем, требуется много меньше скобок чем в Perl 5. Так же как и в Perl 5, по умолчанию переменная цикла $_. Вызов метода say без какого-либо применения, так же как и $_.say. Обратите внимание, что в Perl 6 по умолчанию мы не можем вызвать say без аргумента для $_, мы должны использовать .say либо явно указать $_ в качестве аргумента.

Блок не должен быть обычным блоком. Это может быть острый блок (->), который позволяет нам передавать параметр из цикла в переменную.

for 1, 2, 3, 4 -> $i { $i.say }

Острый блок похож на анонимную подпрограмму, за исключением того, что не ловит значения return. Если мы вызовем return внутри острого блока, будет возвращено enclosing routine.

Острый блок может принимать больше одного параметра из списка. Что произойдет если мы это сделаем?

for 1, 2, 3, 4 -> $i, $j { "$i, $j".say }

Теперь, если мы запустим это, то получим:

1 2
3 4

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

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

for @array { .say }

Хотя во многих простых случаях лучше использовать map:

@array.map: *.say;

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

@array».say;

Но ни одна из этих вещей не является сегодня объектом обсуждения.

Мы можем создать список номеров с помощью конструктора диапазона «..«:

for 1..4 { .say }

Зачастую мы хотим создать список из $n чисел начиная с нуля, таких как индекс массива. Мы могли бы написать 0..$n-1 или использовать вариант конструктора диапазона 0..^$n, но Perl 6 предоставляет удобный инструмент в форме «^«:

for ^4 { .say }

Который выведет:

0
1
2
3

Одной из причин, по которой люди часто ссылаются на C-подобный стиль циклов в Perl 5 является необходимость знать что индекс в массиве они находят для каждого элемента, или необходимость перебирать два или больше массивов параллельно. Perl 6 предлагает для этих целей оператор Z (zip-оператор, оператор «застёжка»).

for @array1 Z @array2 -> $one, $two { ... }

Предполагая, что два массива одинаковой длины, в $one будет каждый элемент массива @array1 и в $two будет соответствующий элемент массива @array2. Если они различной длины, то итерация будет остановлена на последнем элементе самого короткого массива.

Зная это, и зная то, что в Perl 6 есть «ленивые» списки генераторов, мы можем легко включить индекс массива в итерацию:

for ^Inf Z @array -> $index, $item { ... }

Хотя, если бесконечные списки нервируют вас,

for ^@array.elems Z @array -> $index, $item { ... }

даст вам тот же результат, но, возможно, самое элегантное представление:

for @array.kv -> $index, $item { ... }

@array.kv возвращает ключи и значения попарно, где ключи массива являются индексами, так что, повторив итерации над ними два раза, мы получим желаемый эффект.

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

А что, спросите вы, если я захочу перебрать четыре массива за раз?

for @one Z @two Z @three Z @four -> $one, $two, $three, $four { ... }

Вот список ассоциативных инфиксных операторов, то есть — наслаждайтесь.

© Оригинальная статья.

P.S.: Спасибо товарищу bvp за помощь в переводе.

Похожие статьи

• День 8: расчесываем ограничения
• День 6: Входя в Гиперпространство
• День 5: Метаоператоры
• День 4: Тестирование
• День 3: статические типы и мульти-функции

Во-первых, я буду использовать вспомогательную функцию lsay для упрощения и красивого вывода списков.

sub lsay(@a) { @a.perl.say }

Теперь мы можем начать рассматривать примеры гипероператоров. В этой заметке я буду использовать >> и << вместо » и «, в основном потому, что они легче для моих глаз. (Я боюсь, что потребуется взять очки.) » и «, как правило, считаются истинной записью оператора, но ASCII-версия так же будет работать.

Для начала основы: складываем два списка одинаковой длины:

> lsay (1, 2, 3, 4) <<+>> (3, 1, 3, 1)
[4, 3, 6, 5]
> lsay (1, 2, 3, 4) >>+<< (3, 1, 3, 1)
[4, 3, 6, 5]

При одинаковой длине массивов нет никакой разницы между этими формами. Но если длина различна:

> lsay (1, 2, 3, 4) <<+>> (3, 1)
[4, 3, 4, 5]
> lsay (1, 2, 3, 4) >>+<< (3, 1)
Non-dwimmy hyperoperator cannot be used on arrays of different sizes or dimensions.

Как правило, список, на который указывает гипероператор "острым" концом, может быть расширен если он короче чем другой; он расширяется повторением последнего элемента этого списка. В тоже время список, на который указывает "тупой" конец гипероператора, не может быть расширен. Все комбинации разрешены, поэтому вы можете указать на то, что расширена может быть только левая сторона (<<+<<), только правая (>>+>>), обе стороны могут быть расширены (<<+>>), или ни одна из сторон не может быть расширена (>>+<<). Одиночные скаляры так же расширяемы:

> lsay (1, 2, 3, 4) >>+>> 2
[3, 4, 5, 6]
> lsay 3 <<+<< (1, 2, 3, 4)
[4, 5, 6, 7]

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

> lsay ~<<(1, 2, 3, 4)
["1", "2", "3", "4"]
> lsay (1, 2, 3, 4)>>++
[2, 3, 4, 5]

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

> lsay (0, pi/4, pi/2, pi, 2*pi)>>.sin
[0, 0.707106781186547, 1, 1.22464679914735e-16, -2.44929359829471e-16]
> lsay (-1, 0, 3, 42)>>.Str
["-1", "0", "3", "42"]

То есть >>. вызывает метод Str на каждом элементе списка.

Насколько бы вам не хотелось написать @array>>.say, не делайте этого. Это может работать в текущей версии Rakudo, но при использовании гипероператоров вы обещаете что операция параллелизуема, и порядок операций на списке(-ах) не фиксирован. Надеюсь, что в будущих версиях Perl 6 эти операции будут выполняться параллельно.

Другие примечания: Гипероператоры работают не только со встроенными операторами. Они будут работать с любым новым оператором который вы определите. (В основном, сейчас это уже работает в Rakudo.) Гипероператоры будут работать с in-place операторами, напрмиер @a >>/=>> 2 разделит весь массив на 2. (Это не работает в текущей версии Rakudo.) Они будут работать с многомерными списками, с деревьями и с хэшами; смотрите S03 Hyper operators. (Насколько я знаю, они еще не работают в Rakudo.)

Я больше не знаю примеров использования, но область применения гипероператоров достаточно широка. Например класс Vector написанный LastOfTheCarelessMen довольно неплох — это реализация N-мерного вектора без единой явной петли.

© Оригинальная статья.

Похожие статьи

• День 1: Получаем Rakudo
• День 8: расчесываем ограничения
• День 7: Циклы для пользы и развлечения
• День 5: Метаоператоры
• День 4: Тестирование

sub fac(Int $n) {
    [*] 1..$n
}

Итак, как же она работает? Открытие сегодняшней праздничной коробки даст нам ответы на некоторые вопросы!

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

Квадратные скобки являются “метаоператором сокращения”. Они позволяют встроить оператор, находящийся между скобок, в правую часть выражения. Оператор в таких скобках будет помещен между каждой парой элементов списка. Например выражение

[+]  1, $a, 5, $b

можно записать как

1 + $a + 5 + $b

Это дает нам удобный механизм “сумма всех элементов в списке”:

$sum = [+] @a;    # сумма всех элементов массива @a

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

$prod = [*] @a;         # умножение всех элементов @a
$mean = ([+] @a) / @a;  # рассчитать среднее значение @a
$sorted = [<=] @a;      # возвратит true если элементы в @a численно отсортированы
$min = [min] @a, @b;    # находит наименьший элемент в объединенных @a и @b

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

[*] 1..$n

возвращает результат умножения всех чисел от 1 до $n.

Другим полезным метаоператором является “гипер-оператор”. Помещение 

и/или 

(или ASCII эквивалент 

и 

) рядом с оператором превращает его в “гипер-оператор”, который работает с элементами списка. Например следующее поместит в 

результат попарного сложения элементов в 

и 

:

@c = @a »+« @b;

В Perl 5 мы бы написали примерно следующее:

for ($i=0; $i<@a; $i++) {
    $c[$i] = $a[$i] + $b[$i];
}

что выглядит несколько длиннее.

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

# увеличение всех элементов в @xyz на еденицу
@xyz»++

# каждый элемент в @x будет минимальным из @a и @b
@x = @a »min« @b;

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

# умножает каждый элемент @a на 3.5
@b = @a »*» 3.5;

# умножает каждый элемент @x на $m и прибавляет $b
@y = @x »*» $m »+» $b;

# обращает все элементы @x
    @inv = 1 «/« @x;

# объединяет @last, @first и помещает в @full
@full = (@last »~» ', ') »~« @first;

Разумеется, операторы сокращения и гипер-операторы можно использовать одновременно:

# вычислить сумму квадратов элементов в @x
$sumsq = [+] ( @x »**» 2);

Существует много других доступных метаоператоров, включая 

(крест),

(обращение), 

(последовательность). На самом деле “in-place” операторы, такие как 

, 

, 

, являются лишь метаформой оператора равенства:

$a += 5;      # так же как $a = $a + 5;
$b //= 7;     # так же как $b = $b // 7;
$c min= $d;   # так же как $c = $c min $d;

© Оригинальная статья.

Похожие статьи

• День 8: расчесываем ограничения
• День 7: Циклы для пользы и развлечения
• День 6: Входя в Гиперпространство
• День 4: Тестирование
• День 3: статические типы и мульти-функции

Тестирование очень простое. Традиционный perl-way — это выводить данные в Test Anything Protocol. Но вы не должны делать это сами, вы можете использовать для этого специальный модуль.

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

sub fac(Int $n) {
    [*] 1..$n
}

Сейчас нас не интересует как работает функция – мы хотим это выяснить. Так давайте проверим:

use v6;

sub fac(Int $n) {
    [*] 1..$n
}

use Test;
plan 6;

is fac(0), 1,  'fac(0) работает';
is fac(1), 1,  'fac(1) работает';
is fac(2), 2,  'fac(2) работает';
is fac(3), 6,  'fac(3) работает';
is fac(4), 24, 'fac(4) работает';

dies_ok { fac('ох, я же строка') }, 'можно вызывать только с целым аргументом';

И запустим:

$ perl6 fac-test.pl
1..6
ok 1 - fac(0) работает
ok 2 - fac(1) работает
ok 3 - fac(2) работает
ok 4 - fac(3) работает
ok 5 - fac(4) работает
ok 6 - можно вызывать только с целым аргументом

Здесь use Test; загружает модуль тестирования, plan 6; говорит о том, что мы хотим запустить шесть испытаний. Затем идут пять строк шаблона is $got, $expected, $description. is() сравнивает строки, но поскольку целое всегда можно представить строкой, это нормально.

И наконец строкой dies_ok { $some_code }, $description мы проверяем, что вызов функции с нецелым аргументом является критической ошибкой.

Вывод имеет следующий вид: 1..6, затем по одной строке на каждый тест, который начинается на ok (или not ok если тест провален), номер теста, пробел, тире, пробел и описание теста.

Предположим, что вы запускаете больше тестов и не хотите смотреть на вывод каждого, но хотите общий результат. Команда prove из Perl 5 даст вам следующее:

prove --exec perl6 fac-test.pl
fac-test.pl .. ok
All tests successful.
Files=1, Tests=6, 11 wallclock secs ( 0.02 usr  0.00 sys + 10.26 cusr  0.17 csys = 10.45 CPU)
Result: PASS

Вы так же можете поместить все ваши файлы с тестами в отдельную директорию, например t/, и запустить prove рекурсивно на все .t файлы в этой директории:

prove --exec perl6 -r t

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

© Оригинальная статья.

Похожие статьи

• День 8: расчесываем ограничения
• День 7: Циклы для пользы и развлечения
• День 6: Входя в Гиперпространство
• День 5: Метаоператоры
• День 3: статические типы и мульти-функции

В Perl 5, $scalar переменные могут содержать либо ссылки, либо значения. В частности, значениями может быть всё что угодно. Они могут содержать числа, строки, даты: буквально все, что вы пожелаете. Это обеспечивает определенную гибкость, но за счет ясности.

Perl 6 собирается изменить это, введя статические типы. Если вы хотите какую-либо переменную, вы просто помещаете имя типа между my и $variable-type. Например, создание переменной типа Int выглядит следующим образом:

my Int $days = 24;

Другие статические типы могут выглядеть так:

my Str $phrase = "Hello World!";
my Num $pi = 3.141;
my Rat $other_pi = 22/7;

Если вы все еще хотите использовать старое поведение переменных, вы можете не пользоваться статическими типами.

Этот подарок идет рука-об-руку со следующим подарком в коробке: мульти-функции. Что это такое «мульти-функции»? Если коротко, то мульти-функции позволяют перегрузить имена функций (sub). На самом деле мульти-функции могут делать гораздо больше, но эти подарки в другой день. А сейчас посмотрите на несколько примеров использования мульти-функций:

multi sub identify(Int $x) {
    return "$x - целое.";
}

multi sub identify(Str $x) {
    return qq<"$x" - строка.>;
}

multi sub identify(Int $x, Str $y) {
    return "Мы имеем целое $x, и строку \"$y\".";
}

multi sub identify(Str $x, Int $y) {
    return "Мы имеем строку \"$x\", и целое $y.";
}

multi sub identify(Int $x, Int $y) {
    return "Мы имеем два целых $x и $y.";
}

multi sub identify(Str $x, Str $y) {
    return "Мы имеем две строки \"$x\" и \"$y\".";
}

say identify(42);
say identify("Это круто!");
say identify(42, "Это круто!");
say identify("Это круто!", 42);
say identify("Это круто!", "Я гарантирую!");
say identify(42, 24);

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

Оригинальная статья на английском.

Похожие статьи

• День 8: расчесываем ограничения
• День 7: Циклы для пользы и развлечения
• День 6: Входя в Гиперпространство
• День 5: Метаоператоры
• День 4: Тестирование

Разворачиваем второй подарок, который принёс нам на рождество Perl 6, и находим… метод с именем .fmt.

Если вы знакомы со sprintf, то будете чувствовать себя как дома с .fmt. Если же вы не знаете про sprintf или же знаете недостаточно, то подробности можно узнать на соответствующей странице perldoc. Хоть она и длинная, не углубляйтесь. Просто наслаждайтесь этим.

Вернемся к .fmt, храброй младшей сестре sprintf. Вот несколько способов использования .fmt для форматирования строк и чисел:

say 42.fmt('%+d')                # '+42'
say 42.fmt('%4d')                # '  42'
say 42.fmt('%04d')               # '0042'
say :16<1337f00d>.fmt('%X')      # '1337F00D'

Все это хорошо и замечательно, но не более чем короткая форма sprintf. Большое дело, верно?

Я еще не рассказал вам, что метод .fmt перегружен и работает по-разному на массивах (или точнее на списках):

say <huey dewey louie>.fmt       # 'huey dewey louie'
say <10 11 12>.fmt('%x')         # 'a b c'
say <1 2 3>.fmt('%02d', '; ')    # '01; 02; 03'

Кроме того, .fmt так же переопределен и на хэшах:

say { foo => 1, bar => 2 }.fmt   # 'foo     1
                                 #  bar     2'

say { Apples => 5, Oranges => 10 }.fmt('%s cost %d euros')
                                 # 'Apples cost 5 euros
                                 #  Oranges cost 10 euros'

say { huey => 1, dewey => 2, louie => 3 }.fmt('%s', ' -- ')
                                 # 'huey -- dewey -- louie'

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

.fmt является маленьким полезным инструментом, когда вам нужно изменить некоторое значение, или массив, или хеш в некотором заданном формате. Это как sprintf, только еще для массивов и хешей.

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

$ perl6 -e 'say " "x 9-$_,"#"x$_*2-1 for 0..9,2 xx 3'
          #
         ###
        #####
       #######
      #########
     ###########
    #############
   ###############
  #################
         ###
         ###
         ###

Похожие статьи

• День 8: расчесываем ограничения
• День 7: Циклы для пользы и развлечения
• День 6: Входя в Гиперпространство
• День 5: Метаоператоры
• День 4: Тестирование

Для этого вам понадобятся Subversion (svn), git, Perl 5.8 или новее, компилятор языка C и утилита make. В Linux-подобных операционных системах (включая OS X) собрать Rakudo можно следующим образом:

$ git clone git://github.com/rakudo/rakudo.git
$ cd rakudo
$ perl Configure.pl --gen-parrot
$ make
$ make test
$ make install

Здесь опция —gen-parrot указывает Subversion получить сответствующую версию виртуальной машины Parrot и затем компилирует её.

Для текущего Rakudo, make install не установит его в ваше окружение, это фактически подготовит систему так, что вы сможете запускать исполняемый файл perl6 (созданный в директории rakudo) из любой другой директории. После этого вы можете «поиграть» с Perl 6, запустив perl6 без аргументов, что позволит войти в среду REPL, где можно непосредственно вводить команды и видеть что они делают. Это может быть невероятно удобным для ознакомления с работой Perl 6.
Например:

$ ./perl6
> say "Hello world!";
Hello world!
> say (10/7).WHAT
Rat()
> say [+] (1..999).grep( { $_ % 3 == 0 || $_ % 5 == 0 } );
233168

Начинающиеся на $ и > строки — это то, что вы вводите; другие строки — это ответ Rakudo. Первый пример просто выводит текст с помощью say. Второй создаёт рациональное число и запрашивает его тип. Третий создаёт список чисел от 1 до 999, отфильтровывает те, которые не делятся на 3 или 5, суммирует их и выводит результат. (Это первая задача проекта Эйлера, спасибо draegtun за напоминание.) Мы постараемся объяснить как работают эти вещи в будущих постах.

И еще одно замечание. Если у вас возникли трудности в получении Rakudo, то канал #perl6 на irc.freenode.net может оказаться весьма полезным.

Оригинальный текст.

Похожие статьи

• День 6: Входя в Гиперпространство
• День 8: расчесываем ограничения
• День 7: Циклы для пользы и развлечения
• День 5: Метаоператоры
• День 4: Тестирование

Разработчики проекта Rakudo, реализации языка Perl 6 на базе виртуальной машины Parrot, объявили о проведении предрождественского марафона, в рамках которого с 1 по 26 декабря в блоге perl6advent.wordpress.com каждый день будут публиковаться практические уроки, демонстрирующие те или иные возможности Perl 6. В первую неделю декабря в рамках цикла статей было рассказано об установке Rakudo, использованию циклов, операторах форматирования, статических типах, мета-операторах и приемах тестирования.

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

© opennet.ru

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

Что уже можно почитать

День 1: Получаем Rakudo
День 2: Красота Форматирования
День 3: статические типы и мульти-функции
День 4: Тестирование
День 5: Метаоператоры
День 6: Входя в Гиперпространство
День 7: Циклы для пользы и развлечения.
День 8: расчесываем ограничения

Похожие статьи

• День 8: расчесываем ограничения
• День 7: Циклы для пользы и развлечения
• День 6: Входя в Гиперпространство
• День 5: Метаоператоры
• День 4: Тестирование