Слияние кода завершено, страница обновится автоматически
%calories, %calories, больше не используются для нарезки массивов.
& Идентификатор теперь всегда (и больше не требует обратной косой черты) ссылается на функцию объекта именованного подпримера/оператора и не выполняет их, другими словами, рассматривает имя функции как «существительное», а не как «глагол»:
my $sub = \&foo; # Perl 5
my $sub = &foo; # Perl 6
callback => sub { say @_ } # Perl 5 — нельзя напрямую передавать встроенные процессы
callback => &say # Perl 6 — & даёт «существительную» форму любого процесса:
Поскольку Perl 6 после завершения компиляции не позволяет добавлять/удалять символы в области видимости, у Perl 6 нет эквивалента Perl 5 undef &foo; и т. п., и наиболее близким к Perl5 undef &foo; является defined &::("foo") (здесь используется синтаксис «динамического поиска символов»). Тем не менее вы можете использовать my &foo; для объявления изменяемого подпримера, а затем изменить его, присвоив значение &foo во время выполнения.
В Perl 5 & Идентификатор также можно использовать для вызова подпримеров особым образом, который немного отличается от обычного вызова процедуры, и эти специальные форматы больше не доступны в Perl 6:
— &foo(...): избегание прототипа функции
В Perl 6 больше нет прототипов, для вас это не отличается от передачи блока кода или переменной, содержащей код, в качестве аргумента:
# Perl 5:
first_index { $_ > 5 } @values;
&first_index($coderef, @values); # (запрет прототипа и передача блока кода в качестве первого аргумента)
# Perl 6:
first { $_ > 5 }, @values, :k; # :k наречие возвращает индекс первого элемента
first $coderef, @values, :k;
— &foo;: и goto &foo; для повторного использования списка аргументов вызывающего объекта или замены вызывающего стека вызовов:
sub foo { say "before"; &bar; say "after" } # Perl 5
sub foo { say "before"; bar(|@_); say "after" } # Perl 6 — требуется явно передать
# TODO: рекомендуется использовать .callsame в Rakudo
sub foo { say "before"; goto &bar } # Perl 5
# TODO: рекомендуется использовать .nextsame или .nextwith в Rakudo
TODO: для тех случаев использования * globs в Perl 5, которые всё ещё актуальны, и для этой части механизма отражения (перевести) требуется дальнейшее исследование.
В Perl 5 * Идентификатор указывает на структуру GLOB, которая позволяет Perl хранить нелексические переменные, дескрипторы файлов, процедуры и форматы (?formats). (Не путайте с встроенной функцией Perl 5 glob(), которая считывает имена файлов из каталога.)
Вы, скорее всего, столкнётесь с отсутствием поддержки лексических файловых дескрипторов, но необходимостью передать файловый дескриптор процедуре в ранних версиях Perl, где использовался GLOB:
# Perl 5 — старый метод
sub read_2 {
local (*H) = @_;
return scalar(<H>), scalar(<H>);
}
open FILE, '<', $path or die;
my ($line1, $line2) = read_2(*FILE);
Перед переводом на подходящий код Perl6 вам может потребоваться перестроить ваш код Perl5, чтобы удалить зависимость от GLOB:
# Perl 5 — современный способ использования лексических файловых дескрипторов
sub read_2 {
my ($fh) = @_;
return scalar(<$fh>), scalar(<$fh>);
}
open my $in_file, '<', $path or die;
my ($line1, $line2) = read_2($in_file);
Тогда возможный перевод кода на Perl6 будет таким:
# Perl 6
sub read-n($fh, $n) {
return $fh.get xx $n;
}
my $in-file = open $path or die;
my ($line1, $line2) = read-n($in-file, 2);
Теперь индексация и нарезка массива не изменяют sigil переменной, и вы можете использовать наречия для управления типом нарезки:
Индексация:
say $months[2]; # Perl 5
say @months[2]; # Perl 6 — используйте @, а не $
Нарезка значений:
say join ',', @months[6, 8..11]; # Perl5 и Perl6
Нарезка ключ/значение:
say join ',', %months[6, 8..11]; # Perl 5
say join ',', @months[6, 8..11]:kv; # Perl 6 — @ вместо %; использование наречия :kv
Также обратите внимание, что квадратные скобки теперь не являются специальной формой синтаксиса, а представляют собой обычный постфиксный оператор обхода, поэтому проверка существования элементов и удаление элементов выполняются с использованием наречий.
Теперь индексирование и нарезка хеша не изменяют sigil переменной, и вы можете использовать наречия для контроля типа нарезки. Кроме того, элементы в фигурных скобках больше не автоматически заключаются в кавычки (то есть автоматически добавляются двойные кавычки до и после), вместо этого доступны новые версии с квадратными скобками (использующие те же правила построения, что и qw//):
Индексирование:
say $calories{"apple"}; # Perl 5
say %calories{"apple"}; # Perl 6 — % вместо $
say $calories{apple}; # Perl 5
say %calories<apple>; # Perl 6 — квадратные скобки, % вместо $
say %calories«"$key"»; # Perl 6 — двойные квадратные скобки с интерполяцией в виде списка Str
Нарезка значений:
say join ',', @calories{'pear', 'plum'}; # Perl 5
say join ',', %calories{'pear', 'plum'}; # Perl 6 — % вместо @
say join ',', %calories<pear plum>; # Perl 6 (лучшая версия)
my $keys = 'pear plum';
say join ',', %calories«$keys»; # Perl 6 — разделение после интерполяции
Нарезка ключ/значение:
say join ',', %calories{'pear', 'plum'}; # Perl 5
say join ',', %calories{'pear', 'plum'}:kv; # Perl 6 — использование :kv наречия
say join ',', %calories<pear plum>:kv; # Perl 6 (улучшенная версия)
Также обратите внимание, что фигурные скобки больше не являются особой формой синтаксиса, а являются обычным постфиксным оператором обхода, поэтому проверка наличия ключа и удаление ключа выполняются с использованием наречий.
В Perl 5 ссылки на анонимные массивы, хэши и процедуры возвращаются при их создании, ссылки на существующие именованные переменные и процедуры создаются с помощью оператора \.
В Perl 6 анонимные массивы, хэши и процедуры по-прежнему возвращаются при их создании, ссылка на существующую именованную процедуру требует добавления & перед именем процедуры, а ссылка на существующую именованную переменную использует контекст элемента:
my $aref = [ 1, 2, 9 ]; # Используется в perl5&6
my $href = { A => 98, Q => 99 }; # Используется в perl5&6 [*См. примечание*]
my $aref = \@aaa ; # Perl 5
my $aref = item(@aaa) ; В запросе рассматривается использование оператора «=>» в языках Perl 5 и Perl 6.
В языке Perl 5 оператор «=>» используется как запятая, но автоматически добавляет кавычки к параметру слева от него. В Perl 6 оператор «=>» является оператором пары (Pair), что является основным отличием от Perl 5. Однако в большинстве случаев поведение оператора в этих двух языках похоже.
Оператор «=>» применяется при инициализации хеша или передаче параметра методу, который ожидает хеш-ссылку. Также он может использоваться для передачи параметров в виде списка, когда ожидается список пар ключ-значение.
Если необходимо передать параметры без кавычек, рекомендуется использовать вместо «=>» обычную запятую и явно указывать ключи. Также можно изменить интерфейс метода на ожидающий параметры в виде хеша (Hash) или пары (Pair).
Также в запросе рассматриваются другие изменения в синтаксисе между Perl 5 и Perl 6:
Вот его перевод на русский язык:
На самом деле они взаимозаменяемы, Компилятор Perl5 определяет, какой тип цикла использовать, исходя из того, что идёт после точки с запятой.
В цикле for в стиле C в Perl6 используется ключевое слово loop, в остальном всё осталось без изменений: наличие скобок обязательно:
for ( my $i = 1; $i <= 10; $i++ ) { ... } # Perl 5
loop ( my $i = 1; $i <= 10; $i++ ) { ... } # Perl 6
Циклы for или foreach в Perl 6 объединены в цикл for. Цикл foreach больше не является ключевым словом. Правила использования цикла for следующие:
Скобки являются необязательными.
Итерационная переменная, если она есть, перемещается из начала списка в конец. Перед переменной ставится оператор стрелки.
Теперь итерационная переменная — это лексическая переменная. Ключевое слово my больше не требуется, и его использование запрещено.
Переменная итерации — это псевдоним текущего элемента списка. Она доступна только для чтения (в Perl5 псевдоним доступен для чтения и записи), если только вы не замените «->» на «<->». При переносе старого кода проверьте переменные цикла и решите, нужна ли вам возможность чтения и записи.
for my $car (@cars) {...} # Perl 5; чтение и запись for @cars -> $car {...} # Perl 6; только чтение for @cars <-> $car {...} # Perl 6; чтение и запись
Если вы используете переменную по умолчанию $_ и вам нужно иметь возможность читать и писать, то используйте «<->» и явно укажите, что переменная равна $_:
for (@cars) {...} # Perl 5; $_ можно читать и записывать
for @cars {...} # Perl 6; $_ только для чтения
for @cars <-> $_ {...} # Perl 6; $_ можно читать и записывать
Мы также можем получить несколько элементов за один проход цикла, просто добавив дополнительные переменные после стрелки.
my @array = 1..10;
for @array -> $first, $second {
say "First is $first, second is $second";
}
each
Это эквивалент конструкций Perl6 while…each(%hash) или while…each(@array) (перебор элементов структуры данных по ключу и значению):
while (my ($i, $v) = each(@array)) { ... } # Perl 5
for @array.kv -> $i, $v { ... } # Perl 6
while (my ($k, $v) = each(%hash)) { ... } # Perl 5
for %hash.kv -> $k, $v { ... } # Perl 6
Без изменений остались:
Оператор continue был удалён. Вместо него используется блок NEXT:
# Perl 5
my $str = '';
for (1..5) {
next if $_ % 2 == 1;
$str .= $_;
}
continue {
$str .= ':'
}
# Perl 6
my $str = '';
for 1..5 {
next if $_ % 2 == 1;
$str ~= $_;
NEXT {
$str ~= ':'
}
}
Ранее встроенные функции принимали чистый блок кода без дополнительных параметров перед ним. Теперь между блоком и параметрами необходимо вставить запятую, например, map, grep и т. д.
my @results = grep { $_ eq "bars" } @foo; # Perl 5
my @results = grep { $_ eq "bars" }, @foo; # Perl 6
Преобразовано в операторные слова для хеш-индекса и массива:
my $deleted_value = delete $hash{$key}; # Perl 5
my $deleted_value = %hash{$key}:delete; # Perl 6 - use :delete operator word
my $deleted_value = delete $array[$i]; # Perl 5
my $deleted_value = @array[$i]:delete; # Perl 6 - use :delete operator word
Преобразован в операторные слова для хеш-индекса и массива:
say "element exists" if exists $hash{$key}; # Perl 5
say "element exists" if %hash{$key}:exists; # Perl 6 - use :exists operator word
say "element exists" if exists $array[$i]; # Perl 5
say "element exists" if @array[$i]:exists; # Perl 6 - use :exists operator word
Соответствие и замена переменных в Perl5 выполняется с помощью оператора привязки регулярного выражения =~. В Perl6 вместо него используется интеллектуальное сопоставление ~~.
next if $line =~ /static/ ; # Perl 5
next if $line ~~ /static/ ; # Perl 6
next if $line !~ /dynamic/ ; # Perl 5
next if $line !~~ /dynamic/ ; # Perl 6
$line =~ s/abc/123/; # Perl 5
$line ~~ s/abc/123/; # Perl 6
Также можно использовать новые методы .match и .subst. Обратите внимание, что .subst — это операция без возврата значения, см. S05/Substitution.
/(.+)/ and print $1; # Perl 5
/(.+)/ and print $0; # Perl 6
Все модификаторы перемещаются из конца в начало. Возможно, вам потребуется добавить m:i к статическому выражению C«/static/»:
next if $line =~ /static/i ; # Perl 5
next if $line ~~ m:i/static/ ; # Perl 6
Если реальное регулярное выражение слишком сложное, и вы не хотите его изменять, вы можете использовать операторное слово :P5.
next if $line =~ m/[aeiou]/ ; # Perl 5
next if $line ~~ m:P5/[aeiou]/ ; # Perl 6, используйте :P5 операторное слово
next if $line ~~ m/ <[aeiou]> / ; # Perl 6, новый стиль
Регулярная грамматика Perl 5 поддерживает множество специальных форм соответствия, которые не все перечислены здесь. Однако обычно в утверждениях в качестве замены () используется C«<>».
Для классов символов это означает:
[abc] становится C«<[abc]>»[^abc] становится C«<-[abc]>»[a-zA-Z] становится C«<[a..zA..Z]>»[[:upper:]] становится C«<:Upper>»[abc[:upper:]] становится C«<[abc]+:Upper>» <!before arbitrary pattern>* — <after arbitrary* pattern>В Perl6 для LTM (наилучшего соответствия), который выбирает один результат из нескольких на основе правил нечеткого сопоставления, используется символ «|», в отличие от символа «||», который используется в Perl 5 и выбирает результат по позиции. Если ваш код использует «||» вместо «|», результаты могут быть непредсказуемыми. Для сложных совпадений необходимо знать оба метода, особенно понимание стратегии работы LTM. Использование «|» может быть предпочтительнее.
Дополнительные правила можно найти в модуле translate_regex.pl от Blue Tiger.
Pragmas (компилирующие инструкции)
open my $i_fh, '<', $input_path; # ошибка молча игнорируется
use autodie;
open my $o_fh, '>', $output_path; # при ошибке генерируется исключение
В Perl 6:
my $i_fh = open $input_path, :r; # при ошибке генерируется исключение
my $o_fh = open $output_path, :w; # при ошибке генерируется исключение
# Perl 5
package Cat;
use base qw(Animal);
# Perl 6
class Cat is Animal;
use constant DEBUG => 0; # Perl 5
constant DEBUG = 0; # Perl 6
use constant pi => 4 * atan2(1, 1); # Perl 5
pi, e, i — встроенные переменные в Perl 6
Коммандные маркеры
Изменения: -c, -e, -h, -I, -n, -p, -S, -T, -v, -V.
-a: необходимо вручную вызвать .split.
-F: необходимо вручную вызвать .split.
-l: теперь это опция по умолчанию, не нужно указывать явно.
-M, -m: остался только -M, также больше нельзя использовать «no Module» синтаксис, «no» модуль для -M больше не работает.
-E: поскольку все функции уже включены, используйте -e в нижнем регистре.
-d, -dt, -d:foo, -D и т.д.: заменены на ++BUG.
-s: переключатель анализа опций теперь заменяется списком параметров подпрограммы MAIN.
# Perl 5
#!/usr/bin/perl -s
if ($xyz) { print "$xyz\n" }
./example.pl -xyz=5
5
# Perl 6
sub MAIN(Int:$xyz){
say $xyz if $xyz.defined;
}
perl6 example.p6 --xyz=5
5
perl6 example.p6 -xyz=5
5
Операторы для работы с файлами
Построчное чтение текстового файла в массив:
В Perl5 обычно читают строки из текстового файла следующим образом:
open my $fh, "<", "file" or die "$!";
my @lines = <$fh>;
close $fh;
В Perl6 это упрощается до:
my @lines = "file".IO.lines;
Не пытайтесь прочитать весь файл сразу, а затем разделить его с помощью разделителя строк, так как это приведет к тому, что в конце массива будет пустая строка, что больше, чем вы ожидаете (на самом деле это сложнее). Например:
# инициализируем файл для чтения
spurt "test-file", q:to/END/;
first line
second line
third line
END
# читаем файл
my @lines = "test-file".IO.slurp.split(/\n/);
say @lines.elems; #-> 4
Сбор стандартного вывода исполняемого файла:
В Perl5 вы можете сделать это так:
my $arg = 'Hello';
my $captured = `echo \Q$arg\E`;
my $captured = qx(echo \Q$arg\E);
Или используя String::ShellQuote, потому что \Q...\E не совсем правильно:
my $arg = shell_quote 'Hello';
my $captured = `echo $arg`;
my $captured = qx(echo $arg);
Или вы можете использовать Shell, потому что \Q...\E не полностью корректно:
my $arg = 'Hello';
my $captured = run('echo', $arg, :out).out.slurp-rest;
my $captured = run(«echo "$arg"», :out).out.slurp-rest;
Если вы действительно хотите использовать shell, вы можете:
my $arg = 'Hello';
my $captured = shell("echo $arg", :out).out.slurp-rest;
my $captured = qqx{echo $arg};
Однако будьте осторожны, в этом случае нет защиты! Run не использует shell для выполнения команды, поэтому нет необходимости экранировать параметры (они передаются напрямую). Если вы используете shell или qqx, все будет передано в виде длинной строки в shell, если вы не проверите свои параметры тщательно, существует риск внедрения shell-кода из-за такого кода. Путь к модулю Perl
В Perl 5 можно задать дополнительный путь поиска для модулей с помощью переменной среды PERL5LIB:
$ PERL5LIB="/some/module/lib" perl program.pl
Аналогично в Perl 6 нужно изменить только одну цифру, как вы и хотели:
$ PERL6LIB="/some/module/lib" perl6 program.p6
В Perl 5 разделителем для каталогов в PERL5LIB является двоеточие (:), а в Perl 6 — запятая (,). Например:
Неверно:
$ export PERL5LIB=/module/dir1:/module/dir2;
Верно:
$ export PERL6LIB=/module/dir1,/module/dir2;
(Perl 6 не распознаёт PERL5LIB или более старый Perl PERLLIB.)
Что касается Perl 6, если вы не укажете PERL6LIB, вам нужно использовать компиляционную инструкцию use lib для указания пути к библиотеке:
use lib '/some/module/lib'
Обратите внимание, что PERL6LIB в Perl 6 больше предназначен для удобства разработчиков (аналогично PERL5LIB в Perl 5), и пользователям модулей не рекомендуется его использовать, так как в будущем он может быть удалён, поскольку загрузка модулей в Perl 6 напрямую не совместима с операционными системами.
Прочие моменты
'0' — это TrueВ отличие от Perl 5, строка, содержащая только ('0'), является истинной, и в качестве основного типа в Perl 6 она имеет больше смысла. Это означает, что распространённый шаблон:
... if defined $x and length $x; # или length($x) в современном Perl
в Perl 6 упрощается до:
... if $x;
dumpУдалён. В дизайне Perl 6 предусмотрена возможность автоматического сохранения загруженных скомпилированных байт-кодов. На данный момент эта функция поддерживается только для модулей в Rakudo.
Метод FALLBACK предоставляет аналогичную функциональность.
В Perl 5 вы можете выборочно импортировать функции из определённого модуля следующим образом:
use ModuleName qw{foo bar baz};
В Perl 6 функции, которые должны быть экспортированы, должны использовать is export. Все функции, использующие is export, будут экспортированы. Таким образом, следующий модуль Bar экспортирует функции foo и bar, но не baz:
unit module Bar;
sub foo($a) is export { say "foo $a" }
sub bar($b) is export { say "bar $b" }
sub baz($z) { say "baz $z" }
При использовании модуля просто используйте use Bar. Теперь функции foo и bar доступны:
use Bar;
foo(1); #=> "foo 1"
bar(2); #=> "bar 2"
Если вы попытаетесь вызвать функцию baz, вы получите ошибку «неопределённая процедура» во время компиляции.
Итак, как выборочно импортировать функцию из модуля в стиле Perl 5? Для этого вам необходимо определить метод EXPORT в модуле, чтобы указать экспортируемые и удаляемые функции.
Теперь модуль Bar представляет собой файл с именем Bar.pm, содержащий следующее:
use v6.c;
sub EXPORT(*@import-list) {
my %exportable-subs =
'&foo' => &foo,
'&bar' => &bar,
;
my %subs-to-export;
for @import-list -> $import {
if grep $sub-name, %exportable-subs.keys {
%subs-to-export{$sub-name} = %exportable-subs{$sub-name};
}
}
return %subs-to-export;
}
sub foo($a, $b, $c) { say "foo, $a, $b, $c" }
sub bar($a) { say "bar, $a" }
sub baz($z) { say "baz, $z" }
Обратите внимание, что теперь мы не используем is export для явного экспорта функций, мы определили метод EXPORT, который указывает на функции, доступные для экспорта из модуля, и генерируем хеш, содержащий фактически экспортированные функции. @import-list — это список, установленный в коде вызова с использованием оператора use, что позволяет нам выборочно экспортировать функции модуля.
Таким образом, чтобы экспортировать только функцию foo, мы можем использовать:
use Bar <foo>;
foo(1); #=> "foo 1"
Теперь мы обнаруживаем, что даже если bar доступен для экспорта, он не будет доступен, если мы явно не экспортируем его. Поэтому следующий код вызовет ошибку «неопределённая процедура»:
use Bar <foo>;
foo(1);
bar(5); # ошибка «Undeclared routine: bar used at line 3»
Однако мы можем сделать это:
use Bar <foo bar>;
foo(1); #=> «foo 1»
bar(5); #=> «bar 5»
Обратите внимание, что baz по-прежнему недоступен для экспорта, даже если используется <>:
use Bar <foo bar baz>;
baz(3); # ошибка «Undeclared routine: baz used at line 2»
Очевидно, что для того, чтобы это работало должным образом, требуется преодолеть множество препятствий. При использовании стандартного use метода, указав, что функция является экспортируемой с помощью is export, Perl 6 автоматически создаст метод EXPORT правильным образом, поэтому вам следует тщательно рассмотреть, стоит ли создавать собственный метод EXPORT.
Основные модули
В Perl 5 модуль Data::Dumper используется для сериализации и просмотра содержимого программных данных при отладке.
В Perl 6 эти задачи полностью выполняются каждым объектом .perl метода.
# Дано:
my @array_of_hashes = (
{ NAME => 'apple', type => 'fruit' },
{ NAME => 'cabbage', type => 'no, please no' },
);
# Perl 5
use Data::Dumper;
$Data::Dumper::Useqq = 1;
print Dumper \@array_of_hashes; # обратите внимание на обратную косую черту
# Perl 6
say @array_of_hashes.perl; # .perl действует на массив, а не на ссылку
В Perl 5 Data::Dumper имеет более сложные необязательные соглашения о вызовах и поддерживает именование переменных.
В Perl 6 знак равенства, помещённый перед переменной sigil, преобразует её в Pair, ключ которой является именем переменной, а значение — значением переменной.
# Дано:
my ( $foo, $bar ) = ( 42, 44 );
my @baz = ( 16, 32, 64, 'Hike!' );
# Perl 5
use Data::Dumper;
print Data::Ducker->Dump(
[ $foo, $bar, \@baz ],
[ qw( foo bar *baz ) ],
);
# Результат
$foo = 42;
$bar = 44;
@baz = (
16,
32,
64,
'Hike!'
);
# Perl 6
say [ :$foo, :$bar, :@baz ].perl;
# Результат
["foo" => 42, "bar" => 44, "baz" => [16, 32, 64, "Hike!"]]
Параметры переключателя теперь заменяются списком параметров MAIN. Перевод текста на русский язык:
GetOptions( 'length=i' => ( my $length = 24 ), # numeric 'file=s' => ( my $data = 'file.dat' ), # string 'verbose' => ( my $verbose ), # flag ) or die; say $length; say $data; say 'Verbosity ', ($verbose ? 'on' : 'off') if defined $verbose; perl example.pl 24 file.dat perl example.pl --file=foo --length=42 --verbose 42 foo Verbosity on
perl example.pl --length=abc
Value "abc" invalid for option length (number expected)
Died at c.pl line 3.
# Perl 6
sub MAIN( Int :$length = 24, :file($data) = 'file.dat', Bool :$verbose ) {
say $length if $length.defined;
say $data if $data.defined;
say 'Verbosity ', ($verbose ?? 'on' !! 'off');
}
perl6 example.p6
24
file.dat
Verbosity off
perl6 example.p6 --file=foo --length=42 --verbose
42
foo
Verbosity on
perl6 example.p6 --length=abc
Usage:
c.p6 [--length=<Int>] [--file=<Any>] [--verbose]
Обратите внимание, что Perl 6 автоматически генерирует полную информацию о применении при ошибке разбора командной строки.
Автоматический перевод
Один из способов быстро перевести код с Perl 5 на Perl 6 — использовать автоматизированный перевод.
Примечание: эти переводчики ещё не завершены.
Цель этого проекта — автоматизировать модернизацию кода Perl. У него нет веб-интерфейса, поэтому его необходимо устанавливать локально. Также в нём есть отдельная программа для преобразования регулярных выражений Perl 5 в версию Perl 6.
https://github.com/Util/Blue_Tiger/
Онлайн-переводчик.
Этот проект представляет собой кроссплатформенный компилятор Perl, включающий перевод с Perl 5 на Perl 6, и имеет веб-интерфейс, поэтому может использоваться без установки. В настоящее время он поддерживает только подмножество синтаксиса Perl 5.
http://fglock.github.io/Perlito/perlito/perlito5.html
Larry Wall использовал собственный инструмент для перевода кода с Perl 5 на Perl 6, но он устарел и больше не работает с текущими версиями Perl 5.
MAD (Misc Attribute Definition) — это опция конфигурации, доступная при сборке Perl из исходного кода. Программа «perl» анализирует и переводит ваш код Perl в op-tree, выполняя вашу программу путём обхода op-tree. Обычно эти детали анализа отбрасываются, но когда MAD включён, программа «perl» сохраняет эти детали в XML-файл, который затем может быть обработан анализатором MAX для создания кода Perl 6.
Чтобы попробовать MAD, обратитесь к каналу #perl6 за советом по выбору подходящей версии Perl 5.
Модуль Perl::ToPerl6 от Jeff Goff предназначен для преобразования кода Perl 5 с минимальными изменениями в компилируемый код Perl 6. Конвертер настраиваемый и расширяемый, вы можете создавать собственные конвертеры или настраивать существующие в соответствии со своими потребностями. Вы можете получить последнюю версию с CPAN или следить за проектом на GitHub. Онлайн-конвертер может стать доступным в будущем.
Вы можете оставить комментарий после Вход в систему
Неприемлемый контент может быть отображен здесь и не будет показан на странице. Вы можете проверить и изменить его с помощью соответствующей функции редактирования.
Если вы подтверждаете, что содержание не содержит непристойной лексики/перенаправления на рекламу/насилия/вульгарной порнографии/нарушений/пиратства/ложного/незначительного или незаконного контента, связанного с национальными законами и предписаниями, вы можете нажать «Отправить» для подачи апелляции, и мы обработаем ее как можно скорее.
Опубликовать ( 0 )