Perl 6 Index Tablet: Revision 137 / Perl 6

Perl 6

Perl 6 Index Tablet: Revision 137

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

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

This index contains an alphanumeric sorted list of all operators, methods, builtins, options (bold) and some technical terms (italic) with short explanations. Each bold term is followed by a link to a condensed summary of its category in appendix B.

! - logical negation, forces binary context;
! (twigil) - twigil of private class and object variables
!<op> (meta op) - negates (mostly comparsion operators)
!! - second Part of the ternary (conditional) operator after ??
!!! (yadda op) - yadda Operator that calles die
" " (quoting op) - double quoting, interpolate with :s, :a, :h, :f, :c, :b (all vars, functions, blocks, control chars), alias to qq//*
# - starts a comment that continues to the end of the line; works even inside regexes as (regex Metachar)
#`( ) - starts a multi line comment that continues to the end of the line or bracket, works with any combination of bracket pairs
$ (sigil) - prefix of scalar vars
$() (conext op) - forces scalar context, alias to item()
$ (regex Metachar) - end of the string
$$ (regex Metachar) - end of a line
% (sigil) - prefix of hash variables
% (numeric op) - gives remainder of a modulo division, forces numeric context
%() (conext op) - forces hash context, alias to the hash() function
%% (numeric op) - Bool::True if the left is evenly divisible by right value
& (sigil) - sigil of coderefs
& - junctive and, requires that all conditions are met
& (regex Metachar) - match multiple patterns (AND - connection of patterns)
&& (logical op) - logical and, conditonal statements, ends evaluation on the first false expression, returns boolean result
' ' (quoting op) - simple quoting, just / and ' needs o be quoted, alias to q//
() - grouping of values (parameters)
() (regex Metachar) - encompass a subregex/submatch
* (numeric op) - multiplies numbers and forces numeric context on parameters;
* (term) - synonym for Inf (Whatever) in connection with a Range operator (".."); marks the end of an array in a slice operator so that negative indices access array elements relative to one beyond the final element
* - marks as prefix slurpy arrays in signatures
* (twigil) - secondary sigil of global variables
** (numeric op) - raises a number to a power and forces numeric context
** (regex Metachar) - multiplies char or group like x (strig op) outside of regex, (ha)**3 equals (hahaha)
+ (conext op), (numeric op) - forces numeric context of values and adds results
+& (numeric op) - bitwise and, numeric context
++ (prefix & suffix op) - generic autoincrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term
+< (numeric op) - shift left in numeric kontext
+> (numeric op) - shift right in numeric kontext
+^ (numeric op) - bitwise xor in numeric context
+| (numeric op) - bitwise or in numeric context
, - list generating operator
- (numeric op) - forces numeric context and subtract
-- (prefix & suffix op) - generic autodecrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term
--> - alternative syntax to type a parameter
-> - assigns a named parameter for a block (pointy block)
. - secondary sigil for public accessors (getter/setter)
. (regex Metachar) - really any character (unlike Perl 5)
.. - range generating operator; range object in scalar context, see smartmatch table
... (op) - infix operator for list generation
... (yadda op) - term that calls fail (exception), marks unimplemented empty routine bodies
/ (numeric op) - division, numeric context
// (numeric op) - returns the first defined value, similar to orelse
\0[<n>] escape sequence - character given in octal (brackets optional)
: - pair generation operator, also known as adverbial syntax
: (filetest op) - start of all file text ops, syntax: ":" ~ one (<r w x o R W X O e z s f d l p S b c t u g k T B M A C>)
: (twigil) - for autogenerated named parameters of a block
:b<n> - general radix form for literals, makes a number n in base b (up to 36), for example :2<1000001> is 65
: - marks as prefix named parameter in a signature
: - (flow control) - endchar of all labels, jou can jump to (see also goto)
:: (sigil) - abstraction sigil, name space separator (like in Perl 5)
::= - binding a value or variable to a variable at compile time
:= - creates an alias to a variable at runtime (binding)
; - seperates commands (statements) or array indices eg @[2;3] instead of @a[2][3]
< - less than, numeric comparison operator
<-> double pointy syntax to assign a rw parameter to a block
<< (meta op) - applies the operator on the left as hyper operator to the array on the right
<<== - leftward pointing feed operator that adds values to an existing list (append-mode)
<<>> (quoting op) - circumfix quoting operator for grouping with autoquoting and evaluation (alias to Q :qq :ww /.../)
<= - less than or equal, numeric comparison operator
<== - leftward pointing feed operator
<=> - numeric less-equal-greater comparison for Order class
<> (quoting op) - circumfix quoting operator for grouping with autoquoting (alias to Q :q :ww /.../)
<> (regex metachar) - embraces an subrule (assertion)
= (Op) - assignment, left side is evaluated and assigned to the right
<op>= (meta op) - self assignment, left side is one oper and the result is assigned to ($a += 3; equals $a = $a + 3)
=:= (comparison op) - compares binding, if both vars are bound to same memory location
== (comparison op) - equality of value (numeric)
=== (comparison op) - identity, equality of value and type
==> (Op) - rightward pointing feed operator
==>> (Op) - rightward pointing feed operator that adds values to an existing list (append-mode)
=> (comparison op) - pair (and hash) constructor, fatarrow
> (comparison op) - greater than, numeric comparison operator; ends grouping with autoquoting (formerly qw())
>= (comparison op) - greater than or equal, numeric comparison Op
>> (meta op) - binds operator (right) as hyper operator to an array (left)
? (conext op) - forces binary context in an expression
? - marks as postfix optional parameters in signatures
? - quantifier for 0 or 1 occurrence in Regexes
? (twigil) - secondary sigil for constant compiler hint variables
?& - logical op, and combinator, forces binary context
?? !! (logical op) - ternary or conditional operator
??? (yadda op) - yadda operator that calles warn
?^ - logical xor, forces operands into boolean context
?| - logical or, forces operands into boolean context
@ (sigil) - sigil of an array
@() (conext op) - forces (flattened) array context, alias to list() function
<var>[] - postcircumfix operator, appended on an array var, returns an array slice with values which indexes was inside the brackets
[] - circumfix operator that creates a reference to an array that holds all values that encompas these brackets
[] (meta op) - circumfix reduction metaop, close to functional "reduce", applies the operator between all elements of an array
[\<op>] (meta op) - circumfix reduction metaop, 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
\ - capture generator, creates a reference to the following structure
\ - escape char, all escape sequences inside quotes and regexes start with it
^ - junctive xor, requires that one value in a list is true
^ - upto operator, ^$limit expands to 0 ..^ +$limit range
^ - in range definitions, it excludes a limit value, in scalar context see smartmatch
^ (twigil) - for autogenerated positional parameters of a block, position results from alphabetical order of all $^-Variables
^ (regex Metachar) - start of the string
^^ - logical xor, combines expressions, returns true when only one expression is true, otherwise false
^^ (regex Metachar) - start of a line
{} - circumfix operator: encloses blocks and creates a coderef, or a hashref when it is identified as a hash or contains a '=>'
| (junctive op) - junctive or, requires that a condition is fulfilled
| (regex Metachar) - match alternate patterns (OR - connection of patterns)
|() (conext op) - flatten capture object into arglist
|| (logical op) - logical or, evaluates sequentially, ends evaluation at the first expression that returns true
||() (conext op) - flatten capture object into semicolon list
~ (conext op), (string op) - forces string context (stringify) and/or concatenate strings, synonym for cat
~& - characterwise and, forces string context
~< - characterwise left shift, forces string context
~> - characterwise right shift, forces string context
~^ - characterwise xor, forces string context
~| - characterwise or, forces string context
~~ - smartmatch operator, compares (almost) all variable and data types

A

:a (quoting adverb) - demands evaluation of array variables, short form of ":array", included in "", qq and <<>>
:a (regex modifier) - no distinction between same chars with or without accent (funny symbols above), short for ":ignoreaccent"
:aa (regex modifier) - only for substitutions, replacing with chars that have the same accent pattern as the replaced, short for ":sameaccent"
abs (numeric op) - returns numeric absolute value
after (comparison op) - generic comparison operator used by the Order class, true if left should follow right
all - junctive AND operator
and - logical AND operator
andthen - logical AND short circuit operator, transferring $_ from first to second block/command, if first do succeed
anon (scope declarator) - introduces names that aren't to be stored anywhere (anonymous)
Any (undefined value type) - Perl 6 object (default routine parameter type, excludes junction)
any - junctive OR operator
Array (mutable type) - Perl Array, a series of Scalar value container, or a variable that stores such a list
array() (conext op) - forces array context, alias to @()
:array (quoting adverb) - demands evaluation of array variables, long form of ":a", included in "", qq and <<>>
as (string method) - converts like sprintf
as (routine trait) - inner type constraint that a routine imposes on its return value
assoc (routine trait) - specifies the associativity of an operator explicitly
assuming - method of all subroutine reference objects that enables Currying
AST - (abstract syntax tree), tree like data structure, in which source code is transformed, before running the programm
async (block modifier) - allows the interpreter to parallelize the following
augment (scope declarator) - adds definitions to an existing name, inserts new methods and attributes into a class/grammar or replaces them

B

:b (filetest op) - file is a block special file (e.g. Harddisks, CDROMs and RAM areas)
:b (quoting adverb) - forces evaluation of escape sequences, short form of _":backslash", included in "", qq and <<>>
\B escape sequence - Match when not on a word boundary
\b escape sequence - word boundary
:backslash (quoting adverb) _ - forces evaluation of escape sequences, long form of ":b", included in "", qq and <<>>
Backtracking - go after an unsuccessful match back to the last successful matching position and check if another alternative part of the regex matches
Bag (immutable type) - unordered collection of values that allows duplicates
before (comparison op) - generic comparison operator used by the Order class, true when left should precede right
BEGIN "(closure trait)"{} - marks a special block or statement, executed at compile time, ASAP, only ever runs once
Binding - making two variables share the same content by pointing to same memory location
Bit (immutable type) - Perl single bit (allows traits, aliasing, undef, etc.)
Blob - (immutable type) - An undifferentiated mass of bits
Block (immutable type) - Executable objects that have lexical scopes (enclosed by curly braces)
Bool (immutable type) - Perl boolean
break (flow control) - leave this when clause block now
Buf (mutable type) - Perl buffer (a stringish array of memory locations)
but - alters properties of a variable at run time
bytes (string method) - returns number of bytes used (a sort of length)
:bytes (regex modifier) - searching on byte level, (see also chars, codes, graphs)

C

:c (filetest op) - file is a character special file (e.g. terminals modems)
:c (quoting adverb) - forces evaluation of closures (blocks aka { ... }) inside quotes, long form of ":closure", included in "", qq and <<>>
:c(<n>) (regex modifier) - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":continue"
\C[<n>] escape sequence - any character except the bracketed named or control character
\c[<n>] escape sequence - named character or control character
cached (routine trait) - marks a subroutine as being memoized
call - execute a subroutine
caller - object describing the code from which as routine was invoked
callwith - submethode by which one can call a sub with a different signature
capitalize - alias to a wordwise ucirst(lc($_)), makes first char of every word upper case, rest lowercase
Capture (immutable type) - Function call arguments (right-hand side of a binding)
cat (array method) - coverts values of a list into string context and joines them like with '~', alias to .join('')
CATCH (closure trait) - marks a special block to catch exceptions, before LEAVE
category (grammatical category) - namespace of grammatical categories, in case you want to create a new one with a macro
char (num method) - convert number into charakter according a character table, reverse of ord
chars (string method) - returns number of characters
:chars (regex modifier) - searching on character level (default), (see also bytes, codes, graphs)
chdir - changes the current working directory ($*CWD)
CHECK (closure trait) - marks a special block or statement, executed at compile time, ALAP, only ever runs once
chmod - changes access rights of files
chomp (string method) - returns a string with the last newline (if there is one) removed
chop (string method) - returns a string with the last character removed
chown - changes owner of files
circumfix (grammatical category) - operator namespace of ops, that stay after one statement or variable, but do surround a second (like braces in $a[2])
class (block modifier) - declares a collection of methods that define an object
classify (array method) - special form of map, to classify input values; the return value of the closure determines, under which key the value appears in the resulting hash
close - methode on Filehandle class, ending the connection with a file
:closure (quoting adverb) - forces evaluation of closures (blocks aka { ... }) inside quotes, long form of ":c", included in "", qq and <<>>
closure - routines whose state (content of all local variables) is completely preserved until the next execution
cmp (comp op) - compares values textually, gives results -1(lower than), 0 (equal), 1 (greater than), using the Order class
Code - data typ for code references of any kind
:code (quoting adverb) - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: quasi
Coderef - reference (pointer) to an executable block of code (routine)
:codes (regex modifier) - searching on codepoint level (between codepoints), (see also bytes, chars, graphs)
comb (string method) - $str.comb(/pattern/) equals $str ~~ m:g/pattern/, except it returns the list of findings, not a match object like .match aka m//; default pattern is rx/./
compile time - the process when Perl converts source code to executable form
Complex (immutable type) - Perl complex number
constant (var trait) - makes so declared var (is constant) a real constant
contend (block modifier) - marks a block as atomic, concurrent proceses have to wait
Context - when executing a function or operator Perl considers the expression from which the call was to return a scalar or other kind of result
Context variable - $_ is used by built in Perl functions as an implicit parameter
continue (flow control) - makes execution in a 'given' also try the following 'when' clauses
:continue(<n>) - (regex modifier) - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":c"
CONTROL (closure trait) - marks a special block to catch control exceptions (like next/last/return etc), before LEAVE
Cool (undefined value type) - Perl 6 Convenient OO Loopbacks,
copy (parameter trait) - read-writable copy of the original argument ("pass-by-value")
cross (list method) - alias to X operator: @a X @b = (@a; @b).cross
crosswith (list method) - alias to X metaoperator: @a X~ @b = (@a; @b).crosswith(&[~]) = (@a; @b).cross.slice.map { .reduce(&[~]) }
Currying - creating a subroutine as a derivate from another with certain parameter to be predefined

D

:d (filetest op) - check if file is a directory
\D escape sequence - nondigit
\d escape sequence - digit
default (block modifier) - following block will be executed if no when clause in surrounding block matched
Declarative Programming - programming paradigm that expresses the logic of a computation without describing its control flow
defer (block modifier) -
defined - scalar method tests whether a value has been assigned to a variable
delete - removes a key and value from a hash
Design by Contract - programming style in which parameters and return values from routines must meet conditions; A signature is considered contract in Perl 6
die - stop the program now and print a message on $*ERR
dim - array dimensioning
div - division, creates fraction objects in Integer context
do - executes a block (do once loop)
does - checks if an objekt inherits this role
:double (quoting adverb) - double quoting, "q" with interpolation of variables, alias to "...", qq /.../ and Q :s, :a, :h, :f, :c, :b /.../, long for ":qq"
Duration - (immutable type) - The difference between two Instants
dynamic (parameter trait) - parameter is an "environmental" variable, a lexical in the dynamic scope

E

:e (filetest op) - tests if file exists
\E escape sequence - anything but an escape character
\e escape sequence - escape character
each - variant of all() that promises to do things in order, is Positional/Iterable
eager - forces eager evaluation (now), default for scalars
elems (array method) - returns number of elements
else (block modifier) - introduces the alternative block after an 'if' or 'elsif'
elsif (block modifier) - alternative if clause
END (closure trait) - marks a special block, executed at run time, ALAP, only ever runs once
ENTER (closure trait) - marks a special block or statement, executed at every block entry time, repeats on loop blocks
Enum (immutable type) - An immutable Pair
enum - creates a set
EnumMap (immutable type) - A mapping of Enums with no duplicate keys
eq - equal, string comparison
equiv (routine trait) - specifies the precedence of an operator same as an existing operator
eqv - compares the dynamic state of objects and values, in contrast with static ===
err (logical operator) - returns the first defined value from the left
eval - just evaluates a string as a program and returns result and maybe error message in @!, second optional parameter defines a parser grammar which should understand the string
evalfile - behaves like, and replaces Perl 5 do EXPR, with optional $lang support
:ex (regex modifier) - searching at all positions as long as it findes something (with backtracking), short for ":exhaustive"
Exception (immutable type) - Perl exception, errors or abnormal events interfering with normal execution, which Perl 6 can both generate and handle
:exec (quoting adverb) - quoted string will be executed and replaced with its result, alias to Q :x and qx //
:exhaustive (regex modifier) - searching at all positions as long as it findes something (with backtracking), long for ":ex"
exists - checks for existence of a variable or hash member, scalar method
exit - stops all program execution, and returns Int $status (first parameter) to the calling environment

F

:f (filetest op) - file is a plain file (no socket or dir, ...etc.)
:f (quoting adverb) - demands evaluation of functions (subs and methods), that start with "&" and replacing them with the result, long form of ":function", included in "", qq and <<>>
\F escape sequence - anything but form feed
\f escape sequence - form feed
fail - a return call (end this routine) that throws an exception
Failure (undefined value type) - data type object for an error, thrown by an unhandled exception
false - boolean value aka Bool::False
FatRat (immutable type) - Perl rational (unlimited precision in both parts)
ff - flip flop operator in the style of awk, formerly .. in scalar context
fff - flip flop operator in the style of sed, formerly ... in scalar context
FIRST (closure trait) - marks a special block or statement, executed at loop initialization time, before any ENTER
flip (string method) - reverses order of characters in strings
fmt - method on a scalar, takes a format specifier returns a string, simplified sprintf
for (loop block modifier) - only iterates over a list
:function (quoting adverb) - demands evaluation of functions (subs and methods), that start with "&" and replacing them with the result, long form of ":f", included in "", qq and <<>>
Functional Programming - exclusively function based programming style, considered as a branch of Declarative Programming

G

:g (filetest op) - report if file has setgid bit set
:g (regex modifier) - searching for any finding (not just the first), short for :global
gather (block modifier) - performs the following block once, returns a list of all values passed by 'take'
ge (comparison op) - greater than on equal, string comparison
get (handle method) - returns a line (item context) or all lines (list context) from that input stream
given (block modifier) - case construct puts a value into the context variable for when clauses
:global (regex modifier) - searching for any finding (not just the first), long for :g
goto (flow control) - transfer execution to a defined label
grammar - special kind of class to hold regex token and rule definitions
:graphs (regex modifier) - searching on the level of language-independent graphemes, (see also bytes, chars, codes)
grep (array op & method) - gives all values of an array that pass a filters condition
gt (comparison op) - greater than or equal, string comparison, Bool::True if alphabetically ordered the right comes before the left

H

:h (quoting adverb) - demands evaluation of hash variables, long form of ":hash", included in "", qq and <<>>
\H escape sequence - anything but horizontal whitespace
\h escape sequence - horizontal whitespace
handles - delegates execution of a function to another method
HardRoutine - (immutable type) - A routine that is committed to not changing
has (scope declarator) - introduces attribute names
Hash mutable type - Perl hash, a two column table of Scalar, values in one column are keys to refer to the values in the other column
hash (conext op) - enforces hash-list context, alias to %()
:hash (quoting adverb) - demands evaluation of hash variables, long form of ":h", included in "", qq and <<>>
:heredoc (quoting adverb) - defines end marker for the following heredoc, :heredoc is equal to :to
HOW (introspection method) - (reserved for documentation)
hyper - forces none-lazy list context, that ignores the order of results (allowes parallel computing)

I

:i (regex modifier) - uppercase and lowercase variants of a letter are taken as the same letter, short for ":ignorecase" (same as in Perl 5)
if (block modifier) - flow control conditional statement or block modifier, executes code only when a condition expression evaluates to true
:ignoreaccent (regex modifier) - no distinction between same chars with or without accent (funny symbols above), short for ":a"
:ignorecase (regex modifier) - uppercase and lowercase variants of a letter are taken as the same letter, long for ":i" (same as in Perl 5)
:ignoremark (regex modifier) - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, long for ":m"
:ii (regex modifier) - only for substitutions, replacing with chars that have the same case pattern as the replaced, short for ":samecase"
index (string method) - finds the first occurrence of a substring in a string and returns the numerical position, opposite or rindex
Inf - infinity, to generate infinite lazy lists
infix (grammatical category) - operator namespace of ops, that are surrounded by whitespace (\w) between 2 vars or statements ($a + $b)
INIT (closure trait) - marks a special block or statement, executed at run time, ASAP, only ever runs once
inline (sub trait) -
Instant - (immutable type) - A point on the continuous atomic timeline
Int (immutable type) - Perl integer (allows Inf/NaN, arbitrary precision, etc.)
int - extract a whole number value, discarding fractional part
invert (hash op & method) - inverts the key => value relation of a pair or a series of pairs (hash)
IO (mutable type) - Perl filehandle
is - bind a traits to a variable
item() (conext op) - forces scalar context, alias to $()
Iteration - flow control, repeatedly executing a block
Iterator (mutable type) - Perl list

J

join (array op & method) - concatenates list elements into a string, optionally inserting another string between the elements

K

:k (filetest op) - report if file has sticky bit set
KEEP (closure trait) - marks a special block, executed at every successful block exit, part of LEAVE queue
:keepall (regex modifier) - forces subrules to memorize everything (even comments)
key (pair method) - gives the key part of a pair
KeyBag (mutable type) - KeyHash of UInt (does Bag in list/array context)
KeySet (mutable type) - KeyHash of Bool (does Set in list/array context)
keys (hash method) - returns list of hash keys
kv (hash method) - returns list of key-value pairs

L

:l (filetest op) - file is a symbolic link
\L[<n>] escape sequence - everything within the brackets is lowercase
LAST (closure trait) - marks a special block, executed at loop termination time, after any LEAVE
last (flow control) - exit the current looping block
last (array method) - number of final element
lazy - forces lazy evaluation (as late as possible)
lc (string op & method) - make string lowercase
lcfirst (string op & method) - make first char of a string lowercase
le (comparison op) - lower than or equal, string comparison (see lt, gt, ge)
LEAVE (closure trait) - marks a special block, executed at every block exit time
leave (flow control) - exit the current block with a return value
leg (comparison op) - lower/equal/greater comparator for text
let - changes value of a variable temporary, it will be set back if the current block exits unsuccessfully
lines (string method) - returns a chomped list of lines (chunks of character separated by \n) containing a string, $str.lines($limit) equals $input.comb( / ^^ \N* /, $limit )
lines (handle method) - returns an lazy iterator over all chomped lines of that input stream
lines (io op) - reads a file and returns content as array of lines, works as above
lol (conext op) - forces list of list context on a value, meaning a list which values are not contextualized further (can be lists themthelves), opposite of a flattened list
loop (loop block modifier) - general flow control command for repetition
looser (routine trait) - specifies the precedence of an operator lower than an existing operator
lt (comparison op) - lower than, string comparison, Bool::True if alphabetically ordered the left comes before the right

M

m (regex quoting op) - perform a regex based search in place ( stands for match ), similar to rx (quote regex op)
:m (regex modifier) - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, short for ":ignoremark"
Macro (mutable type) - Perl compile-time subroutine
macro - define a routine to alter source code at compile time
map (array op & method) - take a list, perform a block on each member, return a list of the results Arraymethode
Match (mutable type) - Perl match, usually produced by applying a pattern
match (string method) - method alias to m//, $str.match( /pat/ ) equals $str ~~ s/pat/;, returns a match object
match object - result of an regex operation
max (array op & method) - returns the numerically largest value from a given list
maybe (block modifier) -
metaoperator - alters the meaning of other operators
Method (mutable type) - Perl method
method - defines a method (inheritable routine) in a class
min (array op & method) - returns the numerically smallest value from a given list
minmax (array op & method) - returns the highest and lowest values from a list, as a 2 item list
:mm (regex modifier) - substitute with chars that has same mark/accent pattern as the matched string, short for ":samemark"
mod (numeric op) - generic modulo operator
module (block modifier) - introduces a module name, a package that performs special actions on loading
ms (regex quoting op) - perform a regex based search in place, spaces are just subrule separators, alias to m:s/.../ or m:sigspace /.../
Mu (undefined value type) - most (generic) undefined object
multi routine modifier - marks routines with can have sibling with same name but different signature, when called, the one with matching sig is executed (multimethod dispatch)
my (scope declarator) - introduces lexically scoped names, which exists only in the current scope (usually a block)

N

\N escape sequence - anything but (logical) newline
\n escape sequence - (logical) newline
<n> :nd (regex modifier) - demands the nth finding, has many aliases (:st :rd :th) for correct spelling (:2nd)
new - creates a new object of a class, also name of the automatically called constructor method
NEXT (closure trait) - marks a special block, executed at loop continuation time, before any LEAVE
next (flow control) - start the the next following loop iteration
none - return true when a value is not part of a set, junctive NOT operator
normalize - (string method) - normalize (repair) Unicode (UTF) string
not - logical NOT operator, negates truth value, alternative to ! with lower precedence
Num (immutable type) - Perl number (approximate Real, generally via floating point)

O

:O (filetest op) - tests if file is owned by real uid
:o (filetest op) - tests if file is owned by effective uid
Object Oriented Programming - programming paradigm (style), that arranges data and functions that belong together into so called objects
of (routine trait) - inner type constraint that a routine imposes on its return value, eg subset Month of Int where { 1 <= $^a <= 12 }
one - junctive XOR operator
only routine modifier - permits only one routine of the same name in this block
or - logical or operator
ord (string method) - convert charakter into number according a character table, reverse of char
orelse - logical OR short circuit operator, transferring an Error code from first to second block/command, if first do not succeed, similar to //
our (scope declarator) - introduces package - scoped names
:ov (regex modifier) - searching at all positions just one time (with backtracking), short for ":overlap"
:overlap (regex modifier) - searching at all positions just one time (with backtracking), long for ":ov"

P

:p (filetest op) - file is a named pipe (FIFO), or filehandle is a pipe
:p (quoting adverb) - quote paths and create path object that know the right format of the current $*OS with Q :p /.../, short for :path
:p(<n>) (regex modifier) - searching only on the nth (n is an int) position (counting from 0), short for ":pos"
:P5 (regex modifier) - activate old Perl 5 regex rules, alias to :Perl5
pack - repackage values into or from a condensed format
package (block modifier) - defines this Block or File as namespace (almost like in Perl 5), some uses are now better to do with "module" and "class"
Pair (mutable type) - A single key-to-value association
PairSeq (mutable type) - A Seq of Pairs
pair (context op) - force pair context
pairs (hash method) - returns all contents as an array or pairs (key,value)
:panic (regex modifier) - overwriting a possible set :ratchet for all subrules (activates backtracking)
Parameter - value passed to a method or subroutine, mostly as part of the signature
Parcel - (immutable type) - Arguments in a comma list
parcel (parameter trait) - raw reference, will not be contextualized
parsed (routine trait) - this macro will be parsed once, it is hygienic, but own and later defined rules can't be applied, opposite of reparsed
Parsetree - hierarchical data representing the logical structure of a program
:path (quoting adverb) - quote paths and create path object that know the right format of the current $*OS with Q :path /.../, long for :p
perl - evaluates the following string or content of the var on which is called this method, functions with "say" like a better Data::Dumper
:Perl5 (regex modifier) - activate old Perl 5 regex rules, alias to :P5
pick (array op & method) - select a number of random vaues
phaser - Perl 6 term for specially named subblocks withe special runtimes aka closure traits
pick (array method) - selects randomly elements from this list, optional parameter says how many
pipe - connection between 2 processes, move data (mostly only in one direction) without buffering
pointy block - a block that is given parameters with '->'
pop (array op & method) - removes and returns the last element in an array
:pos(<n>) (regex modifier) - searching only on the nth (n is an int) position (counting from 0), long for ":p"
POST (closure trait) - marks a special block, assert postcondition, executed at every block exit, after LEAVE
postcircumfix (grammatical category) - operator namespace of ops, that stay after one statement or variable, but do surround a second (like braces in $a[2])
postfix (grammatical category) - operator namespace of ops, that stay after a statement or variable (like $a++)
PRE (closure trait) - marks a special block, assert precondition, executed at every block entry, before ENTER
prefix (grammatical category) - operator namespace of ops, that stay before a statement or variable (like ++$a)
print - sends characters to an output stream without adding a newline, see 'say'
printf - formats text and sends it to standard output
prompt - "print"ing text and reading the answer (a line from $*IN - formerly STDIN)
property - metadata set at runtime
proto routine modifier - fallback for multi, if no multi routines signature matches the callers, a proto with same name is executed
push (array op & method) - appends a list of values to the end of an array

Q

Q (generalized quoting op) - understands a list of adverbs
q (quoting op) - simple quoting (slashes and '), alias to '...' and Q :q /.../ and Q :single /.../
:q (quoting adverb) - simple quoting (slashes and '), alias to '...' and q /.../, short for ":single"
\Q[<n>] escape sequence - all metacharacters within the brackets match as literal characters
quote (grammatical category) - operator namespace, used to define new quoting ops with a macro
quote_mod (grammatical category) - operator namespace, used to define new quoting adverbs
:quotewords (quoting adverb) - split quoted string on words (on whitespaces) with quote protection (like in shell - '' and "" sourround words), long form of ":quotewords", used in < ... > and << ... >>
qq (quoting op) - double quoting, "q" with interpolation of variables, alias to "..." and Q :s, :a, :h, :f, :c, :b /.../ and Q :qq // and Q :double //
:qq (quoting adverb) - double quoting, "q" with interpolation of variables, alias to "...", qq /.../ and Q :s, :a, :h, :f, :c, :b /.../, short for ":double"
quasi (block modifier) - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: code
qw (quoting op) - splits result on words (as in P5), alias to Q :q :w //
qx (quoting op) - execute as command and return results (as in P5), alias to Q :x //

R

R<op> (meta op) - reverse operands
:R (filetest op) - check if file is readable by real uid/gid
:r (filetest op) - check if file is readable by effective uid/gid
\R escape sequence - anything but return
\r escape sequence - return (CR), as in Perl 5
rand - generate a floating point random number between 0.0 and 1.0
Range (immutable type) - A pair of ordered endpoints
RangeIter (mutable type) - Iterator over a Range
Range Operator - written as '..' in scalar context defines set of possible values for smartmatch, in list context makes a list of successive values
Rat (immutable type) - Perl rational (exact Real, limited denominator)
:ratchet (regex modifier) - deactivates backtracking, search starts at pos, where last match ended
<n> :rd (regex modifier) - demands the nth finding, has many aliases (:st :nd :th) for correct spelling (:3rd)
readline - now called 'get', reads from an input stream until the next newline
readonly (parameter trait) - immutable parameter
redo (flow control) - re-starts processing of the current loop turn
reduce (list method) - alias to [ ] metaoperator: [+] @a = @a.reduce(&[+])
Reference - address of data in memory, often termed a Capture in Perl 6
Regex (mutable type) - Perl pattern
regex - (routine type) - a pattern definition (without :ratchet and :sigspace), can be put in a grammar, similar to qr/.../ in Perl 5
:regex (quoting adverb) - parse as quoted string as regex
Regular Expression - in Perl5: pattern matching notation, either regex, token or rule in Perl6
reparsed (routine trait) - after parsing this macro, it will be reparsed, so that not hygienic, but its own and later defined rules can be applied, opposite of "parsed"
repeat (loop block modifier) - initial command for while or until loops that have their condtion at the end
return (flow control) - leaves a subroutine and sets the return value
returns - sub trait describing the type of value produced by a function
reverse (array op & method) - returns all the members in the opposite order. Use "flip" to turn a string back to front and "invert" for hashes
rindex (string method) - finds the last occurrence of a substring in a string and returns the numerical position, opposite or index
role - container for methods that can extend a class using does
roll (array method) - selects $n (first parameter) values from an array, duplication can occur (like rolling dice)
roundrobin (array method) - kind of zip that ignores empty values: roundrobin([1..3],[1,2],[1]) = 1,1,1,2,2,3
Routine (mutable type) - Base class for all wrappable executable objects
rule - alias for "regex :ratchet :sigspace" in a grammar, see regex, token
Runtime - time when software is being used (not compiletime), or software components necessary for that, or length of time to execute
rw (routine trait) - marks a subroutine as returning an lvalue
rw (parameter trait) - mutable parameter (rw stands for: read write)
:rw (regex modifier) - gives the regex the right to change the string (operand)
rx (regex quoting op) - creates anonymous regex, that can me then assigned into a var, alias to Q :regex // and regex (block modificator)

S

S<op> (meta op) - force sequential (synchronous) evaluation, suppresses any explicit or implicit parallelism
s (regex quoting op) - perform a substitution based on rx-matches in place, creates anonymous regex, alias to Q :subst // and subst (block modificator)
:S (filetest op) - file is a socket
:s (filetest op) - file has size greater than 0
:s (quoting adverb) - demands evaluation of scalar variables, long form of ":scalar", included in "", qq and <<>>
:s (regex modifier) - whitespace separates now subregex and don't stand for spaces to look for, short for ":sigspace", mm// is alias to m:sigspace//
\S escape sequence - anything but whitespace
\s escape sequence - any whitespace character (\h or \v or \t)
:sameaccent (regex modifier) - only for substitutions, replacing with chars that have the same accent pattern as the replaced, long for ":aa"
:samecase (regex modifier) - only for substitutions, replacing with chars that have the same case pattern as the replaced, long for ":ii"
:samemark (regex modifier) - substitute with chars that has same mark/accent pattern as the matched string, long for ":mm"
:samespace (regex modifier) - smart space mapping for substitutions, long for ":ss", ss// is alias to s:samespace///, (ss/teh hsa/the has/;)
say - a function like print that also appends a newline (\n)
Scalar (mutable type) - Perl scalar, variable that holds a single value
:scalar (quoting adverb) - demands evaluation of scalar variables, long form of ":s", included in "", qq and <<>>
Scope - the block of code within which an identifier is usable
seed - initialize a random number generator, optionally with a value
Seq (immutable type) - A list of values (can be generated lazily)
SeqIter (mutable type) - Iterator over a Seq
Set (immutable type) - unordered collection of values that allows no duplicates
sigil (grammatical category) - word to name the namespace for sigils, used to redifine them or define your own with a macro
Signature - (immutable type) - Function parameters (left-hand side of a binding), surrounded by round parentheses
signature (routine trait) - signature of a subroutine. Normally declared implicitly, by providing a parameter list and/or return type
:sigspace (regex modifier) - whitespace separates now subregex and don't stand for spaces to look for, long for for ":s", mm// is alias to m:sigspace//
:single (quoting adverb) - simple quoting (slashes and '), alias to '...' and q /.../, long for ":q"
sleep - Attempt to sleep for up to Num $for seconds (with sub-second resolution)
slice - part of an array or list
slurp (io op and file handle method) - reads a entire file into a string
slurpy Array - array parameter that receives all (slurps) all optional subroutine arguments
SoftRoutine (mutable type) - A routine that is committed to staying mutable
special_variable (grammatical category) - namespace to define and redefine special variables with a macro
splice (array op & method) - remove on $pos (first parameter) $n (second - optional) values and replace them with values (third - optional)
split - makes an array of substrings from a string and a separator
sprintf - inserts formated values out of variables into a string like printf, but returns the string instead of outputting it
ss (regex quoting op) - performs rx based substitution, spaces are just subrule separators, alias to s:samespace/.../.../, e.g.: ss/teh hsa/the has/;
:ss (regex modifier) - only for for substitution, whitespace separates subregexes like :sigspace, but also in the second part, short for ":samespace"
<n> :st (regex modifier) - demands the nth finding, has many aliases (:nd :rd :th) for correct spelling (:1st)
START (closure trait) - marks a special block or statement, executed on first ever execution, once per closure clone
Stash (mutable type) - A symbol table hash (package, module, class, lexpad, etc)
state (scope declarator) - introduces lexically scoped but persistent names (known only in the enclosing block, but retain their values between invocations)
Str (immutable type) - Perl string (finite sequence of Unicode characters)
String - series of characters, text
Sub (mutable type) - Perl subroutine object
sub (block modifier) - defines a subroutine
Submethod (mutable type) - Perl subroutine acting like a method
submethod (block modifier) - defines methods, not inherited by subclasses
Subroutine - block of code callable by name
subset - define a subtype, eg subset Month of Int where { 1 <= $^a <= 12 }
:subst (quoting adverb) - parse as substitution
subst (string method) - method alias to s///, $str.subst( /pat/, "replacement" ) equals $str ~~ s/pat/"replacement/;
substr (string method) - the scalar substring function like in Perl 5
supersede (scope declarator) - replaces definitions of an existing name, e.g. methods and attributes of a class/grammar

T

:t (filetest op) - filehandle is opened to a tty (terminal)
\T escape sequence - anything but a tab
\t escape sequence - tab, not visible character
take - produces a return value in a gather block
temp - defines variables as temporary, synonym for the Perl 5 "local"
term (grammatical category) - namespace of terms, used to redifine them or make a new with a macro
<n> :th (regex modifier) - demands the nth finding, has many aliases (:st :nd :rd) for correct spelling (:2nd)
tighter (routine trait) - specifies the precedence of an operator higher than an existing operator
:to (quoting adverb) - defines end marker for the following heredoc, :to is short for :heredoc
token - kind of regex :ratchet (no backtracking), part of a grammar
Topicalizer - every keyword that sets the $_ variable, eg given, for
touch (filehandle method) - update timestamps on a file
tr (quoting op) - transliteration (as in Perl 5), translating some character in a string into others, alias to Q :trans ///
Trait - additional property of a variable, defined at compile time, see but
:trans (quoting adverb) - evals the quoted as transliteration aka tr ///
trans (string method) - method name for tr/// operation, $str.trans( %mapping ) equals $str ~~ tr/%mapping.sort.keys/%mapping.sort.values/;
triangle (list method) - alias to [\ ] metaoperator: [\+] @a = @a.triangle(&[+])
true (term) - converts value into the boolean context, low precedence alternative to "?"
true - boolean value aka Bool::True
trusts - allows a class the acess to otherwised sealed namespaces
Twigil - second(ary) Sigil indicating a special property of a variable
twigil (grammatical category) - word to name the namespace for twigils, used to redifine them or define your own with a macro

U

:u (filetest op) - report if file has setuid bit set
\U[<n>] escape sequence - everything within the brackets is uppercase
uc - make all string chars uppercase
ucfirst - make first char of a string uppercase
UNDO (closure trait) - marks a special block, executed at every unsuccessful block exit, part of LEAVE queue
unless (block modifier) - flow control modifier, opposite of if, runs block if expression is false
until (block modifier) - opposite of while, runs block repeatedly is long as expression is false
unwrap - remove an enclosing subroutine
use - load a module, import definitions, check Perl version

V

\V escape sequence - anything but vertical whitespace
\v escape sequence - vertical whitespace
value (pair method) - gets value (second) value of a pair
values (hash method) - returns an array of just the values

W

:W (filetest op) - check if file is writeable by real uid/gid
:w (filetest op) - check if file is writeable by effective uid/gid
:w (quoting adverb) - split quoted string on words (on whitespaces), no quote protection, short form of ":words", used in qw//
\W escape sequence - anything but a word character
\w escape sequence - word character (Unicode alphanumeric plus "_")
want - produces a signature object that provides information about the context from which the current routine was called
warn - prints a message on $*ERR
WHAT (introspection method) - short name of the class that an object belongs to
Whatever (undefined value type) - Wildcard (like Any, but subject to do-what-I-mean via multi method dispatch)
WHEN (introspection method) - (reserved for events?)
WHENCE (introspection method) - autovivification of closures
when (block modifier) - executes its code block if a 'given' value smartmatches
WHERE (introspection method) - memory address of the object
where - defines subtypes of data, eg subset Month of Int where { 1 <= $^a <= 12 }_
WHICH (introspection method) - object ID (type)
while (loop block modifier) - flow control modifier runs block repeatedly as long as en expression is true
WHO (introspection method) - package, that support that object, long name in string context
WHY (introspection method) - (reserved for documentation)
will do (routine trait) - block of code executed when the subroutine is called. Normally declared implicitly, by providing a block after the subroutine's signature definition
:words (quoting adverb) - split quoted string on words (on whitespaces), no quote protection, long form of ":w", used in qw//
words (string method) - returns a list of words (chunks of alphanumeric character) containing a string, $input.words($limit) equals $input.comb( / \S+ /, $limit )
wrap - creates enveloping subroutine
:ww (quoting adverb) - split quoted string on words (on whitespaces) with quote protection (like in shell - '' and "" sourround words), short form of ":quotewords", used in < ... > and << ... >>

X

X (list op) - Cross product of two arrays, eg 1,2 X 3,4 == 1,3,1,4,2,3,2,4 ; alias of comb method
x (scalar string op) - string replicate operator to single string, eg 'ab' x 3 == 'ababab'
X<op> (meta op) - Cross product with hyper operator, eg <a b> X~ <y z> == <ay az by bz>
:X (filetest op) - check if file is executable by real uid/gid
:x (filetest op) - check if file is executable by effective uid/gid
:x (quoting adverb) - quoted string will be executed and replaced with its result, alias to Q :exec and qx //
:x(<n>) (regex modifier) - searching n times (n is an int) with this pattern
\X[<n>] escape sequence - anything but the character given in hexadecimal (brackets optional)
\x[<n>] escape sequence - character given in hexadecimal (brackets optional)
xor (scalar bool op) - boolean exclusive or operator, only true if only one operand is true
xx (scalar string op) - string replicate operator to array, eg 'ab' xx 3 == <ab ab ab>

Y

yadda operator - placeholder for later to be written code, because in empty routines are forbidden, comes in 3 flavours: ..., ??? and !!!

Z

Z (list op) - alias to zip (list op) , joines 2 lists eg 1,2,3,4 Z 8,9 == 1,8,2,9
Z<op> (meta op) - joines the values from same position of 2 lists with following operator and produces in that manner a new list
zip (array op & method) - zip operator, joines 2 lists, alias to Z operator @a Z @b = (@a; @b).zip
zipwith (list method) - alias to Z metaoperator: @a Z~ @b = (@a; @b).zipwith(&[~]) = (@a; @b).zip.slice.map { .reduce(&[~]) }

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | T | U | V | W | X | Y | Z

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