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

Variables

Sigils

All variables in Perl begin with a sigil. They mark the 3 primary var types. The 4th sigil is for callables (routines) and the 5th is for layers (namespaces) that organize the previous 4.

$. . . . scalar, single value, can be of any data type
@ . . . ordered array, indexed list of scalar
% . . . unordered hash (associative array), 2 column table with unique IDs (keys) and associated values (value)
&. . . . code/rule/token/regex
:: . . . abstraction: package/module/class/role/subset/enum/type/grammar

The first 4 can also be used as prefix operators, called contextualizers, that force different contexts, but there are much more different contexts then 4.

Twigils

Twigil is short for secondary sigil. They follow after a primary sigil and mark special namespaces or variables with special meanings and properties.

$foo . . . ordinary scoping (no twigil)
$.foo. . . object attribute public accessor
$!foo. . . object attribute private storage
$^foo . . self-declared formal positional parameter
$:foo . . .self-declared formal named parameter
$*foo . . .contextualizable global variable
$?foo . . .compiler hint variable
$=foo . . .pod variable
$<foo> . .match variable, short for $/<foo> or even $/{'foo'}
$~foo . . .the foo sublanguage seen by the parser at this lexical spot

Special Variables

$_. . . . . . . . . context variable
$! . . . . . . . . . error msg

Match Variables

$/ . . . . . . . . . last created match object of this block
$<...> . . . . . . alias to named capture, see Twigils above
$0 .. $9 . . . . . alias to positional capture (most like in P5 - $1 .. $9)
@() . . . . . . . . array that holds $0 .. $9 and rest and positional submatches

Global Variables

context variable, default global (run time), any of them are now objects with several methods

@*ARGS . . . . . Arguments (Parameter) to a program (script), formerly @ARGV
$*ARGFILES. . . magic command-line input handle
$*IN. . . . . . . . standard input handle (command line mostly)
$*OUT. . . . . . . standard output (command line mostly)
$*ERR. . . . . . . standard error output (command line mostly)
$*CWD . . . . . . current working directory (Str)
@*INC. . . . . . . include pathes (but not for std library modules), formerly @INC
$*LANG . . . . . . LANG variable from %*ENV that defines what human language is used
%*ENV . . . . . . system environment variables, formerly %ENV
%*OPTS . . . . . options from command line
$*TZ. . . . . . . . local time zone
$*EXECUTABLE_NAME . former $0
$*PERL . . . . . . perl version running under, was formerly $^V or $]
$*KERNEL . . . . operating system running under
$*DISTRO . . . . OS distribution am I running under
$*PID . . . . . . . ID of the running process,
$*GID . . . . . . . real global ID of the running process owner, formerly @(
$*UID . . . . . . . real user ID of the running process owner (user), formerly @<
$*EGID . . . . . . effective global ID, formerly @)
$*EUID . . . . . . effective user ID, formerly @>
$*ON_DIE . . . . exception handler, run befor die, formerly $SIG{__DIE__}
$*ON_WARN. . . exception handler, run befor warn, formerly $SIG{__WARN__}
$*COMPILING. . .
$*EMERGENCY_MEMORY. . . formerly $^M
$*DEBUGGING . .

Compiler Hint Variables

compiler constants (fixed at compile time)

$?KERNEL . . . . . for which operating System was this program compiled?
$?DISTRO . . . . . Which OS distribution am I compiling under?
$?VM . . . . . . . . Which virtual machine am I compiling under
$?XVM . . . . . . . Which virtual machine am I cross-compiling for
$?PERL . . . . . . . Which Perl am I compiled for?
%?LANG . . . . . . Hash of Grammar # What is the current set of interwoven languages?
$?GRAMMAR. . . . current grammar
$?FILE. . . . . . . . current filename of source file
$?MODULE. . . . . current module
$?PACKAGE . . . . current package
$?CLASS . . . . . . current class
::?CLASS. . . . . . current class (as package name)
$?ROLE . . . . . . . current role (as variable)
::?ROLE. . . . . . . current role (as package or type name)
&?ROUTINE. . . . . current sub or method
&?BLOCK . . . . . . reference to current block
$?LINE. . . . . . . . current line number

POD Variables

File-scoped POD data

$=pod . . . . . . . surrounding POD object
$=data. . . . . . . data block handle (=begin DATA ... =end)
@=COMMENT. . . All the comment blocks in the file

Slang Variables

sublanguage seen by the parser at this lexical spot

$~MAIN . . . . . . the current main language (e.g. Perl statements)
$~Quote. . . . . . the current root of quoting language
$~Quasi . . . . . . the current root of quasiquoting language
$~Regex. . . . . . the current root of regex language
$~Trans . . . . . . the current root of transliteration language
$~P5Regex . . . . the current root of the Perl regex language

Scope Declarator

my . . . . . . . introduces lexically scoped names
state . . . . . . introduces lexically scoped but persistent names
our . . . . . . . introduces package-scoped names
anon . . . . . . introduces names that aren't to be stored anywhere
has . . . . . . . introduces object attribute names
augment. . . . adds definitions to an existing name
supersede. . . replaces definitions of an existing name

Scopes

The following pseudo-package names are reserved at the front of a name:
.
MY. . . . . . . Symbols in the current lexical scope (aka $?SCOPE)
OUR. . . . . . Symbols in the current package (aka $?PACKAGE)
.
CORE. . . . . Outermost lexical scope, definition of standard Perl
GLOBAL . . . Interpreter-wide package symbols, really CORE::GLOBAL
PROCESS . . Process-related globals (superglobals), CORE::PROCESS
COMPILING . Lexical symbols in the scope being compiled
DYNAMIC . . Contextual symbols in my or any caller's lexical scope
.
The following relative names are also reserved but may be used anywhere in a name:
.
CALLER. . . . Contextual symbols in the immediate caller's lexical scope
OUTER . . . . Symbols in the next outer lexical scope
UNIT . . . . . Symbols in the outermost lexical scope of compilation unit
SETTING. . . Lexical symbols in the unit's DSL (usually CORE)
PARENT . . . Symbols in this package's parent package (or lexical scope)
.
The following is reserved at the beginning of method names in method calls:
.
SUPER . . . . Package symbols declared in inherited classes

Value Types

In Perl 6 any variable and value is an object. Here's a list of all different types of values, represented my different classes or roles. The routine types are in a different section.

Undefined types

Mu. . . . . . . . Most Undefined
Failure . . . . . Failure (lazy exceptions, thrown if not handled properly)
Any . . . . . . . Perl 6 object (default routine parameter type, excludes junction)
Cool. . . . . . . Perl 6 Convenient OO Loopbacks
Whatever . . . Wildcard (like Any, but subject to do-what-I-mean via MMD)
Int. . . . . . . . Any Int object
Widget . . . . . Any Widget object

Immutable types

Str . . . . . . Perl string (finite sequence of Unicode characters)
Bit . . . . . . Perl single bit (allows traits, aliasing, undef, etc.)
Int . . . . . . Perl integer (allows Inf/NaN, arbitrary precision, etc.)
Num. . . . . Perl number (approximate Real, generally via floating point)
Rat. . . . . . Perl rational (exact Real, limited denominator)
FatRat. . . . Perl rational (unlimited precision in both parts)
Complex . . Perl complex number
Bool . . . . . Perl boolean
.
Exception . Perl exception
Block . . . . Executable objects that have lexical scopes
Seq . . . . . A list of values (can be generated lazily)
Range. . . . A pair of ordered endpoints
.
Set. . . . . . Unordered collection of values that allows no duplicates
Bag . . . . . Unordered collection of values that allows duplicates
Enum . . . . An immutable Pair
EnumMap. . A mapping of Enums with no duplicate keys
Signature. . Function parameters (left-hand side of a binding)
Parcel . . . . Arguments in a comma list
LoL . . . . . . Arguments in a semicolon list (or equiv, like Z)
Capture . . . Function call arguments (right-hand side of a binding)
Blob . . . . . An undifferentiated mass of bits
Instant. . . . A point on the continuous atomic timeline
Duration. . . The difference between two Instants
HardRoutine A routine that is committed to not changing

Mutable types

Iterator . . . . Perl list
SeqIter . . . . Iterator over a Seq
RangeIter. . . Iterator over a Range
Scalar . . . . . Perl scalar
Array. . . . . . Perl array
Hash. . . . . . Perl hash
KeySet . . . . KeyHash of Bool (does Set in list/array context)
KeyBag . . . . KeyHash of UInt (does Bag in list/array context)
Pair. . . . . . . A single key-to-value association
PairSeq . . . . A Seq of Pairs
Buf . . . . . . . Perl buffer (a stringish array of memory locations)
IO. . . . . . . . Perl filehandle
Routine . . . . Base class for all wrappable executable objects
Sub. . . . . . . Perl subroutine
Method . . . . Perl method
Submethod. . Perl subroutine acting like a method
Macro . . . . . Perl compile-time subroutine
Regex . . . . . Perl pattern
Match . . . . . Perl match, usually produced by applying a pattern
Stash. . . . . . A symbol table hash (package, module, class, lexpad, etc)
SoftRoutine. . A routine that is committed to staying mutable

Low level data types

This is more low level than the last table. These types are more meant to give the compiler optimizing hints.

int1. . . . . . .
int2. . . . . . .
int4. . . . . . .
int8. . . . . . .
int16 . . . . . .
int32. . . . . . (aka int on 32-bit machines)
int64. . . . . . (aka int on 64-bit machines)
int128. . . . . (aka int on 128-bit machines)
uint1. . . . . . (aka bit)
uint2. . . . . .
uint4. . . . . .
uint8. . . . . . (aka byte)
uint16 . . . . .
uint32 . . . . .
uint64 . . . . .
uint128. . . . .
num16 . . . . .
num32 . . . . .
num64 . . . . . (aka num on most architectures)
num128 . . . .
complex16 . .
complex32 . .
complex64 . . (aka complex on most architectures)
complex128 .
rat8. . . . . . .
rat16. . . . . .
rat32. . . . . .
rat64. . . . . .
rat128. . . . .
buf8 . . . . . . aka buf, a "normal" byte buffer
buf16 . . . . . a uint16 buffer
buf32 . . . . . a uint32 buffer
buf64 . . . . . a uint64 buffer

Object Introspection

WHAT . . . . . short name of the class that an object belongs to
WHICH . . . . object ID (type)
WHO. . . . . . package, that support that object, long name in string context
WHERE . . . . memory address of the object
HOW. . . . . . object of meta class: "Higher Order Workings"
WHEN. . . . . (reserved for events?)
WHY. . . . . . (reserved for documentation)
WHENCE . . . autovivification of closures

Operators

Table of precedence

A . . . Level . . . . . . . . . . . . Examples . .
= . ========== . . . ==================
N . Terms . . . . . . . . . . 42 3.14 "eek" qq["foo"] $x :!verbose @$array
L . Method postfix . . . . .meth .+ .? .* .() .[] .{} .<> .<<>> .:: .= .^ .:
N . Autoincrement . . . . ++ --
R . Exponentiation . . . . **
L . Symbolic unary . . . . ! + - ~ ? | || +^ ~^ ?^ ^
L . Multiplicative. . . . . . * / % %% +& +< +> ~& ~< ~> ?& div mod gcd lcm
L . Additive . . . . . . . . . + - +| +^ ~| ~^ ?| ?^
L . Replication . . . . . . . x xx
X . Concatenation . . . . . ~
X . Junctive and . . . . . . &
X . Junctive or . . . . . . . | ^
L . Named unary. . . . . . sleep abs sin temp let
N . Structural infix . . . . but does <=> leg cmp .. ..^ ^.. ^..^
C . Chaining infix . . . . . != == < <= > >= eq ne lt le gt ge ~~ === eqv !eqv
X . Tight and . . . . . . . . &&
X . Tight or . . . . . . . . . || ^^ // min max
R . Conditional. . . . . . . ?? !! ff fff
R . Item assignment . . . = => += -= **= xx= .=
L . Loose unary . . . . . . so not
X . Comma operator . . . , :
X . List infix. . . . . . . . . Z minmax X X~ X* Xeqv ...
R . List prefix. . . . . . . . print push say die map substr ... [+] [*] any Z=
X . Loose and. . . . . . . . and andthen
X . Loose or. . . . . . . . . or xor orelse
X . Sequencer . . . . . . . <== ==> <<== ==>>
N . Terminator . . . . . . . ; {...} unless extra ) ] }

Operator Associativity

Categories

Main

These are the categories of the main language grammar. The first category is the metacategory that can used to produce new ones. Sublanguages such as quoting and regexes can provide their own.

category:<prefix>
circumfix:<( )>
dotty:<.>
infix:<+>
infix_circumfix_meta_operator:{'«','»'}
infix_postfix_meta_operator:<=>
infix_prefix_meta_operator:<!>
package_declarator:<class>
postcircumfix:<( )>
postfix:<++>
postfix_prefix_meta_operator:{'»'}
prefix:<++>
prefix_circumfix_meta_operator:{'[',']'}
prefix_postfix_meta_operator:{'«'}
quote:<q>
routine_declarator:<sub>
scope_declarator:<my>
sigil:<$>
special_variable:<$!>
statement_control:<if>
statement_mod_cond:<if>
statement_mod_loop:<while>
statement_prefix:<do>
term:<*>
trait_auxiliary:<is>
trait_verb:<of>
twigil:<?>
type_declarator:<subset>

Regex

The Regex language has following categories:

assertion:sym<!>
backslash:sym<w>
metachar:sym<.>
mod_internal:sym<P5>
quantifier:sym<*>

Metaoperators

M. appear mostly before or around regular operators and give them different meaning or greater range.
They can be nested like @a X[+=] @b, but be careful with that.
In the example V stands for Value, L for left Value, and R for right. A number is the array index.
Words in the second column are short explanation or an aliasing method if followed by ().

op= . . . self assign. . . known from P5, $L <op>= $R equals $L = $L op $R
!op. . . . negation. . . . known from P5, $L !<op> $R equals !($L op $R)
Rop . . . reverse. . . . . reverses the order of the operands
Sop . . . sequence . . . like reduction, only synchronous, execution in listed order is guaranteed; suppresses any explicit or implicit parallelism
>>op . . hyper . . . . . . processes arrays eager and in parallel or applies a single value to all array elements;
. . . . . . . . . . . . . . . . . @E = $L[0] op $R[0], $L[1] op $R[1], ...;
<<op . . hyper . . . . . . like above, points to the side which determines dimensionality;
. . . . . . . . . . . . . . . . . @E = $L[0] op $R[0], $L[1] op $R[1], ...;
[op]. . . reduce() . . . . applies the operator between all elements of an array;
. . . . . . . . . . . . . . . . . $result = $V[0] op $V[1] op ...;
[\op] . . triangle(). . . . applies above reduction to a series of lists made of array slices ranging in length from 1 to the complete length of the original list;
. . . . . . . . . . . . . . . . . @result = $V[0], $V[0] op $V[1], $V[0] op $V[1] op $V[2], ...;
Xop . . . crosswith(). . . performs the operator to all the pairs of the Cartesian product of two arrays;
. . . . . . . . . . . . . . . . . @result = $L[0] op $R[0], $L[0] op $R[1], $L[1] op $R[0], $L[1] op $R[1]
Zop . . . zipwith() . . . . like hyper, but evaluates lazy
. . . . . . . . . . . . . . . . . @result = $L[0] op $R[0], $L[1] op $R[1], ...

Unicode operators

The two hyper operators can be written with the Unicode "chevron" signs (also documented as "French Quotes") or with double less than or greater than signs (documented as "Texas Quotes").

« aka <<
» aka >>

Contextualizers

Infix operator or functions that forcing a context.

$(). . . . item(). . . . . scalar/item context
? . . . . . so(). . . . . . boolean
! . . . . . not() . . . . . negated bool context
+. . . . . . . . . . . . . . numeric
- . . . . . . . . . . . . . . negated num context
~. . . . . . . . . . . . . . string
@() . . . list() . . . . . array/list context
. . . . . . flat() . . . . . flat list
. . . . . . lol(). . . . . . list of list (was slice context before)
%() . . . hash() . . . . hash context
&(). . . . code() . . . . coderef, routines
| . . . . . . . . . . . . . . flatten capture object into arglist (named parameter)
||. . . . . . . . . . . . . . flatten capture object into semicolon list (positional parameter)

Smartmatch

When used as infix $_ is the left side, X is right. In when clauses just X is stated. Selection of the comparison alhorithm (4th column) is based on the value types as stated in the first two columns.

Filetest Ops

Use it as in "$file.:X" or "$file ~~ :X". (NOTE 2010-11-07: in rakudo this is "$filename.IO ~~ :X")

:r . . . file is readable by effective uid/gid.
:w. . . file is writeable by effective uid/gid.
:x . . . file is executable by effective uid/gid.
:o . . . file is owned by effective uid.
.
:R . . . file is readable by real uid/gid.
:W . . . file is writeable by real uid/gid.
:X . . . file is executable by real uid/gid.
:O . . . file is owned by real uid.
.
:e . . . file exists
:s . . . file has size greater than 0
.
:f . . . file is a plain file.
:d . . . file is a directory.
:l . . . file is a symbolic link.
:p . . . file is a named pipe (FIFO), or filehandle is a pipe.
:S . . . file is a socket.
:b . . . file is a block special file.
:c . . . file is a character special file.
:t . . . filehandle is opened to a tty.
.
:u . . . file has setuid bit set.
:g . . . file has setgid bit set.
:k . . . file has sticky bit set.

Quoting Ops

The basic quoting operator (Q) does nothing, just taking literally what you quoted as a string. But with several adverbs, it behaves like the well known following ops:

Text Processing

Quoting Adverbs

There are a lot more adverbs to fine tune your quoting. The Adverbs can used with any quoting operator like: Q :s/.../ or qq :p /.../.

Regex Modifier

Stay behind the regex op and change the behaviour of the regex, search scope, etc.

Regex Metacharacter

. _______ any character
^ ______ begin of the sring
^^ _____ begin of a line
$ _______ end of the string
$$ ______ end of a line
(...)_____ group patterns and capture the result
[...] _____group patterns without capturing
{...} ____ execute a closure (Perl 6 code) within a rule
<...> ____match a subrule (assertion
| _______ match alternate patterns (logigical OR with LTM)
|| ______ match alternate patterns (sequential OR)
& _______ match multiple patterns (AND)
** ______ muliply this (meta)char/subrule times the following digit on right side
% ______ match this (meta)char/subrule as long as separated by (meta)char/subrule on the right
%% ____ like %, but allows trailing separator
\ _______ escape a metacharacter to get a literal character, or escape a literal character to get a metacharacter
# _______ mark a comment (to the end of the line)
:= ______ bind the result of a match to a hypothetical variable

Quantifier

? _______ zero or one
+ _______ one or more
* _______ zero or more
** ______ maximal greedy matching
** ______ muliply this (meta)char/subrule times the following digit on right side
**? _____ minimal matching
% ______ match this (meta)char/subrule as long as separated by (meta)char/subrule on the right
%%_____ like %, but allows trailing separator

Control Chars

These Escape Sequences will be evaluated inside quotes to invisible control chars, if the ":b" aka ":backslash" quoting Adverbs is set (included in :quotewords and :double). They are also usable in regexes and thatswhy also included in the next list.

\a . . . . . . . . BELL
\b . . . . . . . . BACKSPACE
\e . . . . . . . . ESCAPE
\f . . . . . . . . FORM FEED
\n . . . . . . . . LINE FEED
\r . . . . . . . . CARRIAGE RETURN
\t . . . . . . . . TAB

Escape Sequences

To be used just inside of regexes (m/.../, s/.../.../ and tr/.../.../ and methods like comb('...')).

\0[ ... ] . . character given in octal (brackets optional)
\b . . . . . . word boundary
\B . . . . . . Match when not on a word boundary
\c[ ... ] . . named character or control character
\C[ ... ] . . any character except the bracketed named or control character
\d. . . . . . digit
\D. . . . . . nondigit
\e. . . . . . escape character
\E. . . . . . anything but an escape character
\f . . . . . . form feed
\F. . . . . . anything but a form feed
\n. . . . . . (logical) newline
\N. . . . . . anything but a (logical) newline
\h. . . . . . horizontal whitespace
\H. . . . . . anything but horizontal whitespace
\L[ ... ] . . Everything within the brackets is lowercase
\Q[ ... ]. . all metacharacters within the brackets match as literal characters
\r . . . . . . return
\R. . . . . . anything but a return
\s. . . . . . any whitespace character
\S. . . . . . anything but whitespace
\t . . . . . . a tab
\T. . . . . . anything but a tab
\U[ ... ] . . Everything within the brackets is uppercase
\v. . . . . . vertical whitespace
\V. . . . . . anything but vertical whitespace
\w. . . . . . word character (Unicode alphanumeric plus "_")
\W . . . . . anything but a word character
\x[ ... ] . . character given in hexadecimal (brackets optional)
\X[ ... ] . . anything but the character given in hexadecimal (brackets optional)

zero-width boundaries begin with a pipe symbol

|c . . . . . codepoint boundary (always matches in grapheme/codepoint mode)
|g . . . . . grapheme boundary (always matches in grapheme mode)
|w . . . . . word boundary aka <wb>

Subrules

predefined rules (see routine type rule) for any grammar or regex. They can have prefixes: . (dot) marks a non-capturing subrule, ? and ! are also non-capturing positive and negative zero width assertions,

<alpha> . . . . . . . single alphabetic character
<upper> . . . . . . . uppercase char
<lower> . . . . . . . lowercase char
<digit>. . . . . . . . single digit
<xdigit> . . . . . . . hexadecimal digit
<alnum>. . . . . . . alphanumeric char, equivalent to <+alpha +digit>
<punct> . . . . . . . punctuation char
<ident> . . . . . . . an identifier
<print>. . . . . . . . printable char
<graph> . . . . . . . "graphical" char like kanji
<cntrl>. . . . . . . . control char, e.g. newline and backspace
<blank> . . . . . . . mostly a space or tab
<space> . . . . . . . whitespace character aka \s
<ws> . . . . . . . . . whitespace, roughly equals \s*
<wb> . . . . . . . . . zero-width word boundary, spot with between \w and \W
<ww>. . . . . . . . . zero-width inside word spot between \w and \w
<?before pattern>. zero-width lookahead
<!before pattern>. negative zero-width lookahead, true if the pattern does not match
<?after pattern>. . zero-width lookbehind
<!after pattern> . . negative zero-width lookbehind
<?same>. . . . . . . zero-width between two identical chars
<prior>. . . . . . . . last matched pattern
<?> . . . . . . . . . . matches nothing, always true
<!> . . . . . . . . . . always false

Flow Control

Closure Traits

aka phasers. Every block can contain special named blocks (some are only for loops) that are started at certain times. They are traits (compile time property) of a block object. Those marked with a * can also be used within an expression as in "BEGIN my $x = 3 * 3;".

BEGIN {...}*. . . at compile time, ASAP, only ever runs once
CHECK {...}* . . at compile time, ALAP, only ever runs once
.
INIT {...}*. . . . at run time, ASAP, only ever runs once
END {...}. . . . . at run time, ALAP, only ever runs once
.
START {...}* . . on first ever execution, once per closure clone
ENTER {...}* . . at every block entry time, repeats on loop blocks.
LEAVE {...} . . . at every block exit time
KEEP {...} . . . . at every successful block exit, part of LEAVE queue
UNDO {...}. . . . at every unsuccessful block exit, part of LEAVE queue
.
FIRST {...}*. . . at loop initialization time, before any ENTER
NEXT {...} . . . . at loop continuation time, before any LEAVE
LAST {...} . . . . at loop termination time, after any LEAVE
.
PRE {...} . . . . . assert precondition at every block entry, before ENTER
POST {...} . . . . assert postcondition at every block exit, after LEAVE
.
CATCH {...} . . . catch exceptions, before LEAVE
CONTROL {...}. . catch control exceptions (like next/last/return etc), before LEAVE

Jump Commands

goto . . . . jump to a named label
redo . . . . repeat this loop turn
next . . . . skip to the next loop turn
last. . . . . leave this loop now
break. . . . leave this when clause
leave. . . . leave this block with a return value
return . . . leave this routine with a return value

Conditionals

if . . . . . . when following expression evals in boolean context to True, the block that following after that will be executed
elsif . . . . works like if, but only recognized if no preceding "if" or "elsif" clause was executed
else . . . . following block will be executed, when no preceding "if" or "elsif" clause was executed
unless. . . opposite of if, no "elsif" or "else" is allowed to follow
given . . . evals an expression into scalar context assignes it to $_ for the following block
when . . . smartmatches an expression against $_; if the result is True, the following block will be executed
default . . following block will be executed, when no "when" clause was executed

Loops

loop . . . . general (endless) loop, unless used as an C-style-loop, evals following expression into void context
repeat. . . initial command for while or until loops that have their condtion at the end
while. . . . loop with negative exit condition (exit when False), condition, evals expression into boolean context
until . . . . loop with positive exit condition(exit when True), evals expression into boolean context
for . . . . . evals expression into lazy list context and iterates over that list from first to last value, sets each time $_ (can be combined with when as well),

Routines

routine definition: [ scope ] [modifier] type [name] [trait] (signature) { block }

Routine Types

sub. . . . . . . . normal routine, named block with parmeters
method . . . . . inheritable object methods
submethod. . . not inheritable methods
regex . . . . . . routine that executes a regular expression
rule . . . . . . . alias to regex :ratchet :sigspace
token . . . . . . alias to regex :ratchet
macro. . . . . . routine that is compiled to an AST at BEGIN (ASAP, compile time)
quasi . . . . . . block that is compiled to an AST at runtime

Routine Modifier

multi. . . . . marks routines, witch can have siblings with same name but different signature; when called, the one with matching sig is executed
only . . . . . routines which dont' allow to have an multi sibling (is default, you may leave it out)
proto. . . . . fallback for multi, if no multi signature matches the caller, a proto with same name is executed

Routine Traits

phasers (closure traits) can also be seen as routine traits

export . . . . this routine will be exported my the current module by default
will do . . . . block of code executed when the subroutine is called. Normally declared implicitly, by providing a block after the subroutine's signature definition
signature. . . signature of a subroutine. Normally declared implicitly, by providing a parameter list and/or return type
as . . . . . . . inner type constraint that a routine imposes on its return value
of . . . . . . . official return type of the routine
cached . . . . marks a subroutine as being memoized
rw . . . . . . . marks a subroutine as returning an lvalue
parsed. . . . . macro is parsed once, is hygienic, only parsed can be used
reparsed . . . macro parsed twice, not hygienic, later parsed can be used
tighter. . . . . specifies the precedence of an operator higher than an existing operator as seen here
looser . . . . . specifies the precedence of an operator lower than an existing operator as seen here
equiv . . . . . specifies the precedence of an operator same as an existing operator as seen here
assoc . . . . . specifies the associativity of an operator explicitly as seen here

Parameter Traits

as . . . . . . . data coming through that parameter will be coerced to the type following as
readonly . . . immutable parameter
rw . . . . . . . mutable parameter (rw stands for: read write)
copy. . . . . . read-writable copy of the original argument ("pass-by-value")
dynamic . . . parameter is an "environmental" variable, a lexical in the dynamic scope
parcel. . . . . raw reference, will not be contextualized

Signature Symbols

In routine and block definitions can be also some character with special meaning

! . . . . . suffix of required parameter (default when named, not positional)
* . . . . . prefix of slurpy arrays
-->. . . . prefix of return type (couldn't link the arrow due wiki syntax)
-> . . . . prefix of named readonly parameters for a block (pointy block syntax)
: . . . . . prefix of named parameter, positional when without
::. . . . . prefix of a variable type introduced in a signature
<-> . . . prefix of named writeable parameters for a block (double pointy block syntax)
? . . . . . suffix of optional parameter (default when positional, not named)
^. . . . . prefix of metaclass methods, $obj.^methods(); is shortcut for $obj.HOW.methods($obj);

Callframe Methods

args . . . . .
callframe. .
caller . . . .
file. . . . . .
hints. . . . .
inline . . . .
leave . . . .
line. . . . . .
my . . . . . .
package. . .

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