Perl 6

Perl 6 Basics Tablet: Revision 24

Overview - Chapter: 0:History, 1:Design, 2:Basics, 3:Var, 4:Op, 5:IO, 6:{}, 7:Sub, 8:OOP, 9:Rx, 10:Meta
Intro - Appendices: A:Index, B:Tables, C:Cook, D:Delta, E:Best of, F:Links

1st law of language redesign: Everyone wants the colon for their particular syntax.
2nd law of language redesign: Larry gets the colon for whatever he wants.

Basics doesn't mean here easy but fundamental. Which mostly translates to how to format and reformat data (numbers, strings and more).

Defaults

Please note that any Perl 6 source code is treated as unicode by default. Also use strict; and use warnings; are enabled implicitly. But the interpreter most likely also defaults to read code as Perl 5. To declare sources as Perl 6 you can write:

#!/usr/bin/perl6
use v6.0;
v6;

or just thast with keyword like module or class.

Statements

Unless you use blocks, a Perl program executes one statement after another in linear progression. They have to be separated by a semicolon (;), except before and after a closing curly brace, where it is optional.

Spaces and Indentation

Perl doesn't care about indentation. And spaces are still in many places without meaning. However these have become fewer.

Comments

Single Line

Like in Perl 5 and many other languages of its league, a "#" tells the compiler to ignore the rest of the line.

my $var = 'good'; # that code is boring

Multi Line

#`( )

=begin comment
=end comment

POD

$=

Quoting

Quoting is like regular expression a sublanguage inside the main language with it's own syntactical rules. It is parsed by a special grammar as to be found in the special variable $~Q. The operator with the same name (the generic quoting operator) does almost nothing, just provides a mechanism to mark the beginning and end of text sequence. The examples in this chapter use almost every time slashes for that purpose, but any not alphanumerical character or pair of matching (bracing) character can be used as well.

Q /.../ or Q |...| or Q *...* or Q "..." or Q[...] ...

An extended delimiter mechanism is delivered by heredocs.

Inside of these delimiters, every character will be taken literally. Any additional meaning has to be added by quoting adverbs. Most of them have a short and a long name and some of the most useful have an additional syntax that replaces them altogether with the Q operator.

Single Quotes

No matter which string delimiter is chosen, sometimes he has to occur as a literal character inside the string too. In that case use single quotes with the adverb :single or one of the following aliases, from which ' ' ist maybe the best know. Its also the shortest and easy to understand, but don't allow to add other adverbs.

Q :single /.../;
Q :q /.../;
q /.../;
'...'

Inside single quotes the backslash (\) "quotes" meaning: he liberates the following character from his special meaning. Or to put it simple \\ translates (or interpolates) to \ and \' to '. For anything more you need additional adverbs.

'Welcome in Larry\'s madhouse'
'\'\\'; # string contains: '\
q |\||; # string contains: |

Interpolation

The following adverbs with their short or long version allow a very fine grained definition what to interpolate. The three dots mark here optional content, mostly parameter.

:b aka :backslash # control character (implies at least :q)
:s aka :scalar # scalar variable: $name
:a aka :array # array variable: @name[...]
:h aka :hash # hash variable: %name{...}
:c aka :closure # anonymous blocks: {...}
:f aka :function # callable routines: &name(...)

Q :b /\t\n/; # tab and new line character
Q :s /$poem/; # content of $poem
Q :a /@primes[]/; # all number separated by single spaces
Q :a /@primes[0]/; # returns '2', the first prime
Q :a /me@primes.de/; # returns literally the mail adress, you need the square braces to interpolate arrays
Q :h /%dev{}/; # all developer names (values, not keys) separated by single spaces, angle brackets work too
Q :h /%dev[rakudo] %dev<niecza>/; # just 2 values
Q :h /%dev/; # literally '%dev', you need braces here too
Q :c /There are {2**6} hexagrams in I Ging./; # returns: 'There are 64 hexagrams in I Ging.', inserts the result of the closure
Q :c /Perl 6 Compiler: {%dev.keys}./; # use it too for method calls
Q :h /Perl 6 Compiler: %dev.keys./; # no interpolation
Q :f :a /Here it Tom with the weather: &fetch_report($day)./; # inserts report of that day, even inside Strings the correctness of arguments will be checked!
Q :f :a /fetch_report($day)/; # interpolates just $day
Q :f :a /&fetch_report/; # literal string '&fetch_report', even if the subroutine takes no arguments

Double Quotes

Double quoting combines all the previous mentioned adverbs (also :q - implied by :b), thatswhy all the following are synonymous.

Q :s, :a, :h, :f, :c, :b /.../;
Q :double /.../;
Q :qq /.../;
qq /.../;
"..."

But further adverbs can also be added using q/.../ or qq/.../.

Quote Words

Q :words /.../;
Q :w /.../;
qw/.../
<...>

Q :quotewords /.../;
Q :ww /.../;
<<>>

my @steps = <one two three>;

Heredocs

Are now normal quoted strings, only with a special delimiter, defined by the adverbs to and heredoc. Heredocs can be nested.

Q :to 'EOT';
...
...
EOT

To make templates in which variables and closures are evaluated, take the normal double quote and just add the adverb for the heredoc delimiter or define with other adverbs what exactly you want to have evaluated.

pp:heredoc 'EOT';
EOT

Paths

Q :path /.../;
Q :p /.../;
qp /.../;

Regex

rx// aka Q :regex //
s/// aka Q :subst ///
tr/// aka Q :trans ///

Code

Q :exec /.../;
Q :x /.../;
qx /.../;

Q :code /.../;

Number Literals

Unlike strings, numbers don't need quoting. But if there is a non number character in it, there will be an error. Chars of a number definition are: (0-9,.,+,-,e,E,i,_) including the radix prefixes: (0b,0o,0d,0x) and the prefix for version numbering (v). The + and can act also as operator that convert into the numerical context, which still means: take from left to right all digits and stop with the first none number character.

A single underscore is allowed only between any two digits, delimiter helping readability.

3_456_789; # same as 3456789

$int = 2;
$real = 2.2;

Radix Prefixes

0b binary - base 2, digits 0..1
0o ocatal - base 8, digits 0..7
0d decimal - base 10, digits 0..9
0x hexadecimal - base 16, digits 0..9,a..f (case insensitive)

General Radix Form

:10<42> # same as 0d42 or 42

Scientific Notation

$float = 60.2e23 # becomes automatically 6.02e24
$float = 6.02E-23 # capital E works too

Rational Number

To distinguish them from a division operation, you have to groupe them with braces.

(3/7)
(3/7).numerator
(3/7).denominator
(3/7).nude.perl

As always, .perl gives you an almost source like code formatting which results here in 3/7. Adding .nude you get (3/7), the nude source code. There are 2 different immutable value types representing both rational number. FatRat has unlimited precision and Rat has just enough to be evaled into a Real type. When you explicitly type a variable to one o them, the braces become optional.

my Rat $pi_approx = 22/7;
my FatRat $pi_approx = 2222222222/6981317007; # much more precision

Complex Number

have also there own immutable value type.

1+2i
my $c = 5.2+1e42i;
say $c.WHAT; # returns 'Complex', which is the classname of the value object

Version Number

v1.2.3 # okay
v1.2.* # okay, wildcard version
v1.2.3+ # okay, wildcard version
v1.2.3beta # illegal
Version('1.2.3beta') # okay

Formating

perl

The .perl method returns a string that arranges any set of values in almost the same format, as the would be defined it source code. It's a built in Data::Dumper (pretty printer).

fmt

Small brother of sprinf that works as a method of one value.

sprintf

pack

Formats

moved from core language to a module.