Perl 5 到 Raku 指南 - 简而言之

# the :from<Perl5> makes Raku load Inline::Perl5 first (if installed) 
# and then load the Scalar::Util module from Perl 5 
use Scalar::Util:from<Perl5> <looks_like_number>;
say looks_like_number "foo";   # 0 
say looks_like_number "42";    # 1 

sub test-doesn't-hang { ... }
my $ความสงบ = 42;
my \Δ = 72; say 72 - Δ;

$person->name  # Perl 5 

$person.name   # Raku 

$object->$methodname(@args);  # Perl 5 

$object."$methodname"(@args); # Raku

# unidiomatic but valid Perl 5 
say"Hello ".ucfirst  ($people
    [$ i]
    ->
    name)."!"if$greeted[$i]<1;

substr ($s, 4, 1); # Perl 5 (in Raku this would try to pass a single 
                       #         argument of type List to substr) 

substr($s, 4, 1);  # Raku 
substr $s, 4, 1;   # Raku - alternative parentheses-less style 

my($alpha, $beta);          # Perl 5, tries to call my() sub in Raku 

my ($alpha, $beta);         # Raku 

if($a < 0) { ... }          # Perl 5, dies in Raku 

if ($a < 0) { ... }         # Raku 
if $a < 0 { ... }           # Raku, more idiomatic 

while($x-- > 5) { ... }     # Perl 5, dies in Raku 

while ($x-- > 5) { ... }    # Raku 
while $x-- > 5 { ... }      # Raku, more idiomatic 

$seen {$_} ++; # Perl 5 

%seen{$_}++;   # Raku 

$n<1;   # Perl 5 (in Raku this would conflict with postcircumfix < >) 

$n < 1; # Raku 

# Perl 5 
my @books = $xml
  ->parse_file($file)          # some comment 
  ->findnodes("/library/book");

# Raku 
my @books = $xml
  .parse-file($file)           # some comment 
  .findnodes("/library/book");

my $sub = \&foo; # Perl 5 

my $sub = &foo;  # Raku 

callback => sub { say @_ }  # Perl 5 - can't pass built-in sub directly 

callback => &say            # Raku - & gives "noun" form of any sub 

# Perl 5: 
first_index { $_ > 5 } @values;
&first_index($coderef, @values); # (disabling the prototype that parses a 
                                     # literal block as the first argument) 

# Raku: 
first { $_ > 5 }, @values, :k;   # the :k makes first return an index 
first $coderef, @values, :k;

sub foo { say "before"; &bar;     say "after" } # Perl 5 

sub foo { say "before"; bar(|@_); say "after" } # Raku - have to be explicit 

sub foo { say "before"; goto &bar } # Perl 5 

proto foo (|) {*};
multi foo ( Any $n ) {
    say "Any"; say $n;
};
multi foo ( Int $n ) {
    say "Int"; callsame;
};
foo(3); # /language/functions#index-entry-dispatch_callsame 

# Perl 5 - ancient method 
sub read_2 {
    local (*H) = @_;
    return scalar(<H>), scalar(<H>);
}
open FILE, '<', $path or die;
my ($line1, $line2) = read_2(*FILE);

# Perl 5 - modern use of lexical filehandles 
sub read_2 {
    my ($fh) = @_;
    return scalar(<$fh>), scalar(<$fh>);
}
open my $in_file, '<', $path or die;
my ($line1, $line2) = read_2($in_file);

# Raku 
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);

say $months[2]; # Perl 5 

say @months[2]; # Raku - @ instead of $ 

say join ',', @months[6, 8..11]; # Perl 5 and Raku 

say join ',', %months[6, 8..11];    # Perl 5 
say join ',', @months[6, 8..11]:kv; # Raku - @ instead of %; use :kv adverb 

say $calories{"apple"}; # Perl 5 

say %calories{"apple"}; # Raku - % instead of $ 

say $calories{apple};   # Perl 5 

say %calories<apple>;   # Raku - angle brackets; % instead of $ 
say %calories«"$key"»;  # Raku - double angles interpolate as a list of Str 

say join ',', @calories{'pear', 'plum'}; # Perl 5 

say join ',', %calories{'pear', 'plum'}; # Raku - % instead of @ 
say join ',', %calories<pear plum>;      # Raku (prettier version) 
my $keys = 'pear plum';
say join ',', %calories«$keys»;          # Raku the split is done after interpolation

say join ',', %calories{'pear', 'plum'};    # Perl 5 

say join ',', %calories{'pear', 'plum'}:kv; # Raku - use :kv adverb 
say join ',', %calories<pear plum>:kv;      # Raku (prettier version) 

my $aref = \@aaa  ; # Perl 5 

my @array = 4,8,15;
{ $_[0] = 66 }(@array);   # run the block with @array aliased to $_ 
say @array; #  OUTPUT: «[66 8 15]» 

# Perl 5 
    say $arrayref->[7];
    say $hashref->{'fire bad'};
    say $subref->($foo, $bar);

# Perl 5.20 
    use experimental qw< postderef >;
    my @a = $arrayref->@*;
    my %h = $hashref->%*;
    my @slice = $arrayref->@[3..7];

# Raku 
    my @a = $contains-an-array.list;        # or @($arrayref) 
    my %h = $contains-a-hash.hash;          # or %($hashref) 

# Raku 
    my @a = $contains-an-array[];
    my %h = $contains-a-hash{};

my @numbers = 100, 200, 300;
my @more_numbers = 500, 600, 700;
my @all_numbers = |@numbers, 400, |@more_numbers;

# Infix ops (two arguments; one on each side of the op) 
+&  +|  +^  And Or Xor: Numeric
~&  ~|  ~^  And Or Xor: String
?&  ?|  ?^  And Or Xor: Boolean
 
# Prefix ops (one argument, after the op) 
+^  Not: Numeric
~^  Not: String
?^  Not: Boolean (same as the ! op)

say 42 << 3; # Perl 5 

say 42 +< 3; # Raku 

sub get_the_loot { ... }; # Raku stub 
# Works in Perl 5 and Raku 
my %hash = ( AAA => 1, BBB => 2 );
get_the_loot( 'diamonds', { quiet_level => 'very', quantity => 9 }); # Note the curly braces 

# Perl 5 
sub get_the_loot {
    my $loot = shift;
    my %options = @_;
    # ... 
}
# Note: no curly braces in this sub call 
get_the_loot( 'diamonds', quiet_level => 'very', quantity => 9 );

# Raku, original API 
sub get_the_loot( $loot, *%options ) { # The * means to slurp everything 
    ...
}
get_the_loot( 'diamonds', quiet_level => 'very', quantity => 9 ); # Note: no curly braces in this API 
 
# Raku, API changed to specify valid options 
# The colon before the sigils means to expect a named variable, 
# with the key having the same name as the variable. 
sub get_the_loot( $loot, :$quiet_level?, :$quantity = 1 ) {
    # This version will check for unexpected arguments! 
    ...
}
get_the_loot( 'diamonds', quietlevel => 'very' ); # Throws error for misspelled parameter name 

my $result = $score > 60 ?  'Pass' :  'Fail'; # Perl 5 

my $result = $score > 60 ?? 'Pass' !! 'Fail'; # Raku 

$food = 'grape' . 'fruit'; # Perl 5 

$food = 'grape' ~ 'fruit'; # Raku 

# Perl 5 
    print '-' x 80;             # Print row of dashes 
    @ones = (1) x 80;           # A list of 80 1's 
    @ones = (5) x @ones;        # Set all elements to 5 

# Raku 
    print '-' x 80;             # Unchanged 
    @ones = 1 xx 80;            # Parentheses no longer needed 
    @ones = 5 xx @ones;         # Parentheses no longer needed 

if (my $x = dostuff()) {...}  # Perl 5 

if dostuff() -> $x {...}      # Raku 

given EXPR {
    when EXPR { ... }
    when EXPR { ... }
    default { ... }
}

given $value {                   # assigns $_ 
    when "a match" {             # if $_ ~~ "a match" 
        # do-something(); 
    }
    when "another match" {       # elsif $_ ~~ "another match" 
        # do-something-else(); 
    }
    default {                    # else 
        # do-default-thing(); 
    }
}

while (my $x = dostuff()) {...}  # Perl 5 

while dostuff() -> $x {...}      # Raku 

while (<IN_FH>)  { } # Perl 5 

for $IN_FH.lines { } # Raku 

# Perl 5 
do {
    ...
} while $x < 10;
 
do {
    ...
} until $x >= 10;

# Raku 
repeat {
    ...
} while $x < 10;
 
repeat {
    ...
} until $x >= 10;

for  ( my $i = 1; $i <= 10; $i++ ) { ... } # Perl 5 

loop ( my $i = 1; $i <= 10; $i++ ) { ... } # Raku

for my $car (@cars)  {...} # Perl 5; read-write 

for @cars  -> $car   {...} # Raku; read-only 
for @cars <-> $car   {...} # Raku; read-write 

for (@cars)      {...} # Perl 5; $_ is read-write 

for @cars        {...} # Raku; $_ is read-write 
for @cars <-> $_ {...} # Raku; $_ is also read-write 

my @array = 1..10;
for @array -> $first, $second {
    say "First is $first, second is $second";
}

while (my ($i, $v) = each(@array)) { ... } # Perl 5 

for @array.kv -> $i, $v { ... } # Raku 

while (my ($k, $v) = each(%hash)) { ... } # Perl 5 

for %hash.kv -> $k, $v { ... } # Raku 

# Perl 5 
    my $str = '';
    for (1..5) {
        next if $_ % 2 == 1;
        $str .= $_;
    }
    continue {
        $str .= ':'
    }

# Raku 
    my $str = '';
    for 1..5 {
        next if $_ % 2 == 1;
        $str ~= $_;
        NEXT {
            $str ~= ':'
        }
    }

# Raku 
    my $str = '';
    for 1..5 {
        next if $_ % 2 == 1;
        $str ~= $_;
        NEXT $str ~= ':';
    }

my @results = grep { $_ eq "bars" } @foo; # Perl 5 

my @results = grep { $_ eq "bars" }, @foo; # Raku 

my $deleted_value = delete $hash{$key};  # Perl 5 

my $deleted_value = %hash{$key}:delete;  # Raku - use :delete adverb 

my $deleted_value = delete $array[$i];  # Perl 5 

my $deleted_value = @array[$i]:delete;  # Raku - use :delete adverb 

say "element exists" if exists $hash{$key};  # Perl 5 

say "element exists" if %hash{$key}:exists;  # Raku - use :exists adverb 

say "element exists" if exists $array[$i];  # Perl 5 

say "element exists" if @array[$i]:exists;  # Raku - use :exists adverb

next if $line  =~ /static/  ; # Perl 5 

next if $line  ~~ /static/  ; # Raku 

next if $line  !~ /dynamic/ ; # Perl 5 

next if $line !~~ /dynamic/ ; # Raku 

$line =~ s/abc/123/;          # Perl 5 

$line ~~ s/abc/123/;          # Raku

/(.+)/ and print $1; # Perl 5 

/(.+)/ and print $0; # Raku 

next if $line =~    /static/i ; # Perl 5 

next if $line ~~ m:i/static/  ; # Raku 

next if $line =~    m/[aeiou]/   ; # Perl 5 

next if $line ~~ m:P5/[aeiou]/   ; # Raku, using P5 modifier 
next if $line ~~ m/  <[aeiou]> / ; # Raku, native new syntax 

use v5.22;
"þor is mighty" =~ /is (?<iswhat>\w+)/n;
say $+{iswhat};

"þor is mighty" ~~ /is \s+ $<iswhat>=(\w+)/;
say $<iswhat>;

/ word #`(match lexical "word") / 

my $foo;             # Perl 5 
BEGIN { $foo = 42 }

BEGIN my $foo = 42;  # Raku 

# Perl 5 
open my $i_fh, '<', $input_path;  # Fails silently on error 
use autodie;
open my $o_fh, '>', $output_path; # Throws exception on error 

# Raku 
my $i_fh = open $input_path,  :r; # Returns Failure on error 
my $o_fh = open $output_path, :w; # Returns Failure on error 

# Raku 
if open($input_path,:r) -> $handle {
    .say for $handle.lines;
}
else {
    # gracefully handle the fact that the open() failed 
}

# Perl 5 
package Cat;
use base qw(Animal);

# Raku 
class Cat is Animal {}

use constant DEBUG => 0; # Perl 5 

constant DEBUG = 0;      # Raku 

use constant pi => 4 * atan2(1, 1); # Perl 5 

tau, pi, e, i; # built-in constants in Raku 
τ, π, 𝑒        # and their unicode equivalents 

my int $foo = 42;
my int $bar = 666;
say $foo * $bar;    # uses native integer multiplication 

say Animal.^mro;    # .^ indicates calling a meta-method on the object 

# Perl 5 
    #!/usr/bin/perl -s 
    if ($xyz) { print "$xyz\n" }
./example.pl -xyz=5
5

# Raku 
    sub MAIN( Int :$xyz ) {
        say $xyz if $xyz.defined;
    }

raku example.p6 --xyz=5
5
raku example.p6 -xyz=5
5

open my $fh, "<", "file" or die "$!";
my @lines = <$fh>;                # lines are NOT chomped 
close $fh;

my @lines = "file".IO.lines;  # auto-chomped 

# initialize the file to read 
spurt "test-file", q:to/END/; 
first line
second line
third line
END
# read the file 
my @lines = "test-file".IO.slurp.split(/\n/);
say @lines.elems;    #-> 4 

my @lines = "test-file".IO.slurp.lines;  # also auto-chomps 

my $fh = open('./bad/path/to/file', :w) or die $fh;

my $fh = open('./bad/path/to/file', :w) orelse .die;

my $fh = open('./bad/path/to/file', :w).self;

my $arg = 'Hello';
my $captured = `echo \Q$arg\E`;
my $captured = qx(echo \Q$arg\E);

my $arg = shell_quote 'Hello';
my $captured = `echo $arg`;
my $captured = qx(echo $arg);

my $arg = 'Hello';
my $captured = run('echo', $arg, :out).out.slurp;
my $captured = run(«echo "$arg"», :out).out.slurp;

my $arg = 'Hello';
my $captured = shell("echo $arg", :out).out.slurp;
my $captured = qqx{echo $arg};

$ PERL5LIB="/some/module/lib" perl program.pl

$ PERL6LIB="/some/module/lib" raku program.p6

$ export PERL5LIB=/module/dir1:/module/dir2;

$ export PERL6LIB=/module/dir1,/module/dir2;

use lib '/some/module/lib'

... if defined $x and length $x; # or just length() in modern perls 

... if $x;

use ModuleName qw{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(1);    #=> "foo 1" 
bar(2);    #=> "bar 2" 

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" }

use Bar <foo>;
foo(1);       #=> "foo 1" 

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" 

use Bar <foo bar baz>;
baz(3);       #!> "Undeclared routine: baz used at line 2" 

unit module Bar;
sub foo() is export { }                   # added by default to :DEFAULT 
sub bar() is export(:FNORBL) { }          # added to the FNORBL export group 
sub baz() is export(:DEFAULT:FNORBL) { }  # added to both 

use Bar;                     # imports foo / baz 
use Bar :FNORBL;             # imports bar / baz 
use Bar :ALL;                # imports foo / bar / baz 

# Given: 
    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; # Note the backslash. 

# Raku 
say @array_of_hashes.perl; # .perl on the array, not on its reference. 

# Given: 
    my ( $foo, $bar ) = ( 42, 44 );
    my @baz = ( 16, 32, 64, 'Hike!' );
# Perl 5 
    use Data::Dumper;
    print Data::Dumper->Dump(
        [     $foo, $bar, \@baz   ],
        [ qw(  foo   bar   *baz ) ],
    );
# Output 
#    $foo = 42; 
#    $bar = 44; 
#    @baz = ( 
#             16, 
#             32, 
#             64, 
#             'Hike!' 
#           ); 

# Raku 
say [ :$foo, :$bar, :@baz ].perl;
# OUTPUT: «["foo" => 42, "bar" => 44, "baz" => [16, 32, 64, "Hike!"]]» 

# Raku 
dd $foo, $bar, @baz;
# OUTPUT: «Int $foo = 42
# Int $bar = 44
# Array @baz = [16, 32, 64, "Hike!"]
# » 

# Perl 5 
    use 5.010;
    use Getopt::Long;
    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.

# Raku 
    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');
    }

raku example.p6
    24
    file.dat
    Verbosity off
raku example.p6 --file=foo --length=42 --verbose
    42
    foo
    Verbosity on
raku example.p6 --length=abc
    Usage:
      c.p6 [--length=<Int>] [--file=<Any>] [--verbose]