Perl6::Perl5::Differences -- Differences between Perl 5 and Perl 6
This document is intended to be used by Perl 5 programmers who are new to Perl 6 and just want a quick overview of the main differences. More detail on everything can be found in the language reference, which have been linked to throughout.
This list is currently known to be incomplete.
Where you used to say:
my @fruits = ("apple", "pear", "banana");
print $fruit[0], "\n";
You would now say:
my @fruits = "apple", "pear", "banana";
say @fruit[0];
Or even use the <> operator, which replaces qw():
my @fruits = <apple pear banana>;
Note that the sigil for fetching a single element has changed from $ to @; perhaps a better way to think of it is that the sigil of a variable is now a part of its name, so it never changes in subscripting.
The same applies to hashes:
say "There are %days{'February'} days in February";
Again, there is a shorter form:
say "There are %days<February> days in February";
For details, see "Names and Variables" in S02.
Yes, a twigil. It's the second character in the variable name. For globals, it's a *; for contextual variables, it's +.
Was: $ENV{FOO}
Now: %*ENV<FOO>
Or: $+FOO # might be overridden, but falls back to %*ENV
For details, see "Names and Variables" in S02.
Number of elements in an array:
Was: $#array+1 or scalar(@array)
Now: @array.elems
Index of last element in an array:
Was: $#array
Now: @array.end
Therefore, last element in an array:
Was: $array[$#array]
Now: @array[@array.end]
@array[-1] # also works
For details, see "Built-In Data Types" in S02
Old New
--- ---
__LINE__ $?LINE
__FILE__ $?FILE
__PACKAGE__ $?PACKAGE
__END__ =begin END
__DATA__ =begin DATA
See "double-underscore forms are going away" in S02 for details. The ? twigil refers to data that is known at compile time.
A comprehensive list of operator changes is documented at "Changes to Perl 5 operators" in S03 and "New operators" in S03.
Some highlights:
qw() has a customary form; new interpolating form Was: qw(foo)
Now: <foo>
Was: ("foo", (split /s+/, $bar), "bat")
Now: <<foo $bar bat>>
Quoting operators now have modifiers that can be used with them (much like regexes and substitutions in Perl 5), and you can even define your own quoting operators. See S03 for details.
See S04 for the full specification of blocks and statements in Perl6.
Was: if ($a < $b) { ... }
Now: if $a < $b { ... }
Likewise for while, for, etc.
Using eval on a block is now replaced with try.
Was: eval {
# ...
};
if ($@) {
warn "oops: $@";
}
Now: try {
# ...
CATCH { warn "oops: $!" }
}
CATCH provides more flexiblity in handling errors. See "Exception_handlers" in S04 for details.
Was: foreach (@whatever) { ... }
Now: for @whatever { ... }
Also, the way of assigning to something other than $_ has changed:
Was: foreach my $x (@whatever) { ... }
Now: for @whatever -> $x { ... }
This can be extended to take more than one element at a time:
Was: while (my($age, $sex, $location) = splice @whatever, 0, 3) { ... }
Now: for @whatever -> $age, $sex, $location { ... }
(Except the for version does not destroy the array.)
See "The for statement" in S04 and "each" in S29 for details.
Was: for ($i=0; $i<10; $i++) { ... }
Now: loop ($i=0; $i<10; $i++) { ... }
loop can also be used for infinite loops:
Was: while (1) { ... }
Now: loop { ... }
Here's a simple translation of a Perl5 regular expression to Perl6:
Was: $str =~ m/^\d{2,5}\s/i
Now: $str ~~ m:P5:i/^\d{2,5}\s/
The :P5 modifier is there because the standard Perl6 syntax is rather different, and 'P5' notes a Perl5 compatibility syntax. For a substitution:
Was: $str =~ s/(a)/$1/e;
Now: $str ~~ s:P5/(a)/{$0}/;
Notice that $1 starts at $0 now, and /e is gone in favor of the embedded closure notation.
For the full specification, see S05. See also:
The related Apocalypse, which justifies the changes:
http://dev.perl.org/perl6/doc/design/apo/A05.html
And the related Exegesis, which explains it more detail:
http://dev.perl.org/perl6/doc/design/exe/E05.html
For details see :
http://dev.perl.org/perl6/doc/design/apo/A07.html Format Apocalypse
http://dev.perl.org/perl6/doc/design/exe/E07.html Format Exegesis
Was: $object->method
Now: $object.method
Was: $self.$coderef() Now: $coderef(self:)
Was: if (-r $file && -x _) {...}
Now: if $file ~~ :r & :x {...}
For details, see "Changes to Perl 5 operators"/"The filetest operators now return a result that is both a boolean" in S03
You now use <em>kwid</em> for documentation instead of POD. Kwid is a wiki-like syntax that is easy to write, and pleasant to read directly.
Here is a side-by-side comparison of some of the major features of Pod and Kwid:
=head1 Big Thing = Big Thing
=head4 Small Thing ==== Small Thing
A paragraph of A paragraph of
plain text. plain text.
# verbatim # verbatim
sub v { sub v {
shift; shift;
} }
=item * foo * foo
=item * bar * bar
=item2 N<> barber ++ barber
=item2 N<> bard ++ bard
Something B<strong>! Something *strong*!
Something I<emphatic>! Something /emphatic/!
Some code C<E = M * C ^ 2>! Some code `E = M * C ^ 2`!
Some V<B<escaped>> markup Some \*escaped\* markup
=begin Section_type .Section_type
=end Section_type !Section_type
=for Section_type :Section_type
See S26 for details.
A number of builtins have been removed. For details, see:
Capture objects fill the ecological niche of references in Perl 6. You can think of them as "fat" references, that is, references that can capture not only the current identity of a single object, but also the relative identities of several related objects. Conversely, you can think of Perl 5 references as a degenerate form of Capture when you want to refer only to a single item.
Was: ref $foo eq 'HASH' Now: $foo ~~ Hash Was: @new = (ref $old eq 'ARRAY' ) ? @$old : ($old); Now: @new = @$old; Was: %h = ( k => \@a ); Now: %h = ( k => @a );
To pass an argument to modify by reference:
Was: sub foo {...}; foo(\$bar)
Now: sub foo ($bar is rw); foo($bar)
The "obsolete" reference above has the details. Also, look for Capture under "Names_and_Variables" in S02, or at the Capture FAQ, Perl6::FAQ::Capture.
This is a version of print that auto-appends a newline:
Was: print "Hello, world!\n";
Now: say "Hello, world!";
Since you want to do that so often anyway, it seemed like a handy thing to make part of the language.
wantarray is superseeded by want.list. Also available are want.item and want.count, the latter gives the number of expected values, if applicable.
Hash elements no longer auto-quote:
Was: $days{February}
Now: %days{'February'}
Or: %days{"February"}
Or: %days<February>
Or: %days<<February>>
The curly-bracket forms still work, but curly-brackets are more distinctly block-related now, so in fact what you've got there is a block that returns the value "February". The <> and <<>> forms are in fact just quoting mechanisms (see below).
Most (all?) built-in functions are now methods of built-in classes such as String, Array, etc.
Was: my $len = length($string);
Now: my $len = $string.chars;
Was: print sort(@array);
Now: print @array.sort;
@array.sort.print;
You can still say sort(@array) if you prefer the non-OO idiom.
Kirrily "Skud" Robert, <skud@cpan.org>, Mark Stosberg, Trey Harris