Perl 6 Index Tablet

Herbert Breunung — Tue, 17 Apr 2012 00:54:35 -0000

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

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 (sorted without prefixes like colon, slash, sigil or twigil) of all operators, methods, builtins, options, modifier and special variables with short explanations. Each bold term is followed by a link (in round brackets) to a condensed summary listing of its category in appendix B. Sometimes are added placeholder for parameter in angle brackets. stands for a integer number, is a floating point number, ~~string, any variable, any operator and~~

~~for a regex pattern.~~

Before alpha chars (a-z) come the other in ASCII order: !"# $%& '(* +,- ./0 :;< =>? @[\ ^_{ |~

! (context op) - logical negation (NOT), forces boolean context, high precedence version of not

! (twigil) - twigil of private class and object variables

! (signature symbol) - suffix for a required parameter in signatures, thats default if it's a named parameter, not is it's a positional

! (meta op) - negates (mostly comparison operators )

$! - (special var) - last error message

(predefined subrule) - inverse of , returns always false

!! (conditional op) - just second part of the ternary (conditional) operator after ??, no op on its own

!!! (yadda op) - yadda operator that calls die

" " (quoting op) - double quoting, interpolates with :s, :a, :h, :f, :c, :b (all vars, functions, blocks, control chars), alias to qq/.../ or Q :qq /.../

# - starts a comment that continues to the end of the line; works even inside regexes as a regex metachar

#= - starts comments to the lineending like #, just makes documenting comments that end up in &routine.WHY.content on the following routine

#`( ) - starts a multi-line comment that continues to the closing bracket, works with any combination of bracket pairs

$ (sigil) - prefix of scalar variables

$() (context op) - forces scalar context, alias to the item() function

$ (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

%() (context op) - forces hash context, alias to the hash() function

% (regex metachar) - quantifier that repeat char or group as long as separated by right expression - example: \d % ',' matches 1,2,3,4,5

%% (numeric op) - True if the left value is evenly divisible by the right value

%% (regex metachar) - quantifier that repeat char or group as long as separated by right expression like %. but allows trailing separator - example: \d %% ',' matches 1,2,3,4,5,

& (sigil) - sigil of callables like subs, methods and other blocks

&() (context op) - forces callable context, alias to code

& (junctive op) - junctive AND, requires that all conditions are met, see also: all

& (regex metachar) - match multiple patterns (AND-connection of patterns)

&& (logical op) - short circuit AND, evals right side if left side returns True, high precedence version of and

' ' (quoting op) - simple quoting, just / and ' must be escaped, alias to q/.../ or Q :q/.../

() - grouping of values (parameters)

() (regex metachar) - encompass a subregex / submatch , results land in @() or $0... (not limited to $9 anymore)

@() - (special var) - holds positional submatches, $()[n] is alias to $/[n] and $n

* (numeric op) - multiplies numbers, forces numeric context

* (term) - synonym for Whatever, for example, means Inf in a range operator (..), means the end of an array in a slice operator so that negative indices access array elements relative to one beyond the final element

* (signature symbol) - prefix which indicates slurpy arrays in signatures

* (twigil) - twigil of global variables

* (regex metachar) - quantifier for zero or more findings

** (numeric op) - raises a number to a power, forces numeric context

** (regex metachar) - not backtracking, greedy quantifier taking zero or more findings

** (regex metachar) - quantifier for explicit repeat char or group, like x (string op) does outside of a regex; for example, (ha)**3 matches (hahaha)

+ (context op), (numeric op) - infix addition operator, forces numeric context

+ (regex metachar) - quantifier for one or more findings

+& (numeric op) - bitwise AND, forces numeric context

++ (sequence traversal) - generic autoincrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term, alias to succ

+< (numeric op) - shift left in numeric context

+> (numeric op) - shift right in numeric context

+^ (numeric op) - bitwise XOR in numeric context

+| (numeric op) - bitwise OR in numeric context

, - list-generating operator

- (numeric op) - infix subtraction operator, forces numeric context (and negates)

-- (sequence traversal) - generic autodecrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term, alias to pred

--> (signature symbol) - declares the type of the return value of a routine, type name is placed after this arrow at the end of a signature

-> (signature symbol) - declares named parameters for a block ("pointy block"{link:Perl 6 Glossary Tablet pointy block})

. (twigil) - twigil of public accessors (getter/setter)

. (regex metachar) - matches any character (including a newline, unlike in Perl 5)

.. (ranges), (list op) - infix range generating operator, produces a Range object in item context

... (list op) - infix sequence generating operator, infix operator for list generation

... (yadda op) - term that calls fail (exception), marks unimplemented empty routine bodies

/ (numeric op) - divides numbers, forces numeric context

/ (rat composer) - inside round brackets (for example (3/7)), gives you a rational number ( immutable type ) that keeps track of its numerator and denominator

$/ - (special var) - last created match object of this block

// (logical op) - short circuit defined or, returns the first defined value (from left to right), similar to ||, high precedence version of err

\0B[] (escape sequence) - character given in octal, decimal or hex (when B is 'o', 'd' or 'x'), brackets are optional, first number has to be inside okt/dec/hex range, alternate syntax without the zero is preferred

$0 (special var) - first positional submatch, there is $1, $2, ... too (don't stops at $9 like Perl 5), alias to $()[0] and $/[0], former $0 is now $*EXECUTABLE_NAME

: - pair generation operator, also known as adverbial syntax

: (filetest op) - start of all file test ops - example: ":" ~ one ()

: (twigil) - twigil of autogenerated named parameters of a block

:B - general radix form for literals, makes a number N in base B (up to 36) - example: :2<1000001> is decimal 65

: ~~(flow control) - suffix of all labels you can jump to with goto~~

: (signature symbol) - prefix of a named parameter in a signature, they are positional when without colon

:: (sigil) - abstraction sigil and namespace separator in variable / routine / namespace names (like in Perl 5)

:: (signature symbol) - introducing a type variable in a signature

::= - binds a value or variable to a variable at compile time

:= - creates an alias to a variable at runtime (binding)

; - separates statements (commands) or array indices; for example, @[2;3] instead of @a[2][3]

< (num comparison) - infix op, less than, True if numerically ordered the left comes before the right operand

<-> (signature symbol) 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

<<== (sequencer op) - leftward pointing feed operator that adds values to an existing list (append-mode)

<< >> (quoting op) - circumfix quoting operator for grouping with autoquoting and evaluation of variables, alias to Q :qq :ww /.../

<= (num comparison) - less than or equal, numeric comparison operator see also < and >=

<== (sequencer op) - leftward pointing feed operator, take return value of right side and feed as parameter to the left, see also =>

<=> (num comparison) - numeric less-equal-greater comparison for sortable classes, does cmp in numeric context as leg does in string context

< > (quoting op) - circumfix quoting operator for grouping with autoquoting, alias to Q :q :ww /.../ or qw/.../

< > (twigil) - circumfix twigil of named captures, $<...> is alias to $/<...>, was $& and $MATCH in Perl 5

< > (regex metachar) - embraces an subrule (assertion)

= (Op) - assignment, right side is evaluated and assigned to the left

= (twigil) - pod variable, mapped content from pod sections of this file - examples: $=pod and $=data

= (meta op) - self assignment, left side is one operand and place where the result is assigned to - example: ($a += 3; equals $a = $a + 3)

=:= (comparison op) - compares binding, if both vars are bound to same memory location

== (num comparison) - True if values are equal in numerical context, as eq does in string context

=== (comparison op) - checks for infix identity, equality of value and type

==> (sequencer op) - rightward pointing feed operator, take return value of left side and feed as parameter to the right

==>> (sequencer op) - rightward pointing feed operator that adds values to an existing list (append-mode)

=> (op) - pair (and hash) constructor, fatarrow

> (num comparison) - infix op, numeric greater than

>= (num comparison) - infix op, numeric greater than or equal

>> (meta op) - binds operator (right) as hyper operator to an array (left)

? (context op) - forces boolean context in an expression, returns False when value is 0 or empty, otherwise True, high precedence version of so

? (signature symbol) - suffix for optional named parameters in signatures

? (regex metachar) - quantifier for 0 or 1 occurrence in Regexes

? (twigil) - twigil (secondary sigil) for constant compiler hint variables

(predefined subrule) - matches nothing, returns always True, opposite of

?& (bool op) - logical AND op, and combinator, forces binary context

?? !! (conditional op) - ternary or conditional operator, shortcut for if and else, see also ff and fff

??? (yadda op) - yadda operator that calles warn

?^ (bool op) - logical XOR, forces operands into boolean context

?| (bool op) - logical OR, forces operands into boolean context

@ (sigil) - sigil of an array

@() (context op) - forces (flattened) array context, alias to list() function

[ ] - 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, applies the operator between all elements of an array, alias to reduce

[\] (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, alias to triangle

\ - capture generator, creates a capture that holds the following structure

\ - escape char, all escape sequences inside quotes and regexes start with it

^ (junctive op) - junctive XOR, requires that one value in a list is True, see also one

^ - upto operator, ^$limit expands to 0 ..^ +$limit range

^ (ranges) - in range definitions, it excludes a limit value, in scalar context see smartmatch

^ (twigil) - autogenerated positional parameters of a block, position results from alphabetical order of all $^-Variables

^ (signature symbol) - prefix of metaclass methods, $obj.^methods(); is shortcut for $obj.HOW.methods($obj);

^ (regex Metachar) - start of the string

^^ (logical op) - logical XOR, combines expressions, returns True when only one expression is true, otherwise false, high precedence version of xor

^^ (regex Metachar) - start of a line

$_ (special var) - context var, result of the last command, can set by topicalizers (given and for)

{} - 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, see also: any

| (regex Metachar) - match alternate patterns with longest token matching (OR - temporal simultaneous connection of patterns)

|() (context op) - flatten capture object into arglist, (named parameter)

|| (logical op) - short circuit OR, evaluates sequentially, ends evaluation at the first expression that returns True, high precedence version of or

|| (regex Metachar) - match alternate patterns (temporal consequent alternatives) as connected with a logical OR

||() (context op) - flatten capture object into semicolon list, (positional parameter)

~ (context op), (string op) - forces string context (stringify) and/or concatenate strings, alias for cat

~ (twigil) - twigil for a grammar of a sublanguage like $~MAIN

~& (string op) - characterwise AND, forces string context

~< (string op) - characterwise left shift, forces string context

~> (string op) - characterwise right shift, forces string context

~^ (string op) - characterwise XOR, forces string context

~| (string op) - characterwise or, forces string context

~~ (comparison op) - smartmatch operator, compares (almost) all variable and data types according a table

A

:a (quoting adverb) - demands evaluation of array variables that starting with the @-sigil, short form of :array, included in "...", qq/.../ and <<...>>

abs (numeric op) - returns numeric absolute value, converts value in numeric context

after (generic comparison) - generic comparison operator used by the Order class, True if left should follow right

> (predefined subrule) - negative zero-width lookbehind, if before this position is something that matches the pattern inside the angle brackets, the whole pattern will not match

> (predefined subrule) - positive zero-width lookbehind, only if this position is preceded by the given pattern inside the angle brackets, the whole pattern will match

all (junctive op) - junctive AND operator, True if all conditions (elements of a following list) are fulfilled, see also: &

(predefined subrule) - a single alphanumeric character, equivalent to <+alpha +digit>

(predefined subrule) - a single alphabetic character

and (logical op) - short circuit logical AND, returns the last defined value (from left to right), low precedence version of &&, similar to andthen

andthen (logical op) - logical AND short circuit operator, transferring $_ from first to second block/expression, if first do succeed, see also: orelse

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 op) - junctive OR operator, True when any one condition (of a following list) is true in bool context, see also: |

$*ARGFILES (special var) - magic command-line input handle, was ARGV in P5

@*ARGS (special var) - arguments (parameter) to a program (script), formerly @ARGV

arity (routine method) - returns how many parameters this routine requires, .count includes also the optional

Array (mutable type) - Perl Array, a series of Scalar value container, or a variable that stores such a list

:array (quoting adverb) - demands evaluation of array variables that starting with the @-sigil, long form of :a, included in "...", qq/.../ and <<...>>

as (parameter trait) - data coming through that parameter will be coerced to the type following as

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

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 grammar or replaces them, see also: supersede

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) - zero-width word boundary aka

:backslash (quoting adverb) - forces evaluation of escape sequences, long form of :b, included in "...", qq/.../ and <<...>>

Bag (immutable type) - unordered collection of values that allows duplicates

base - returns a Str representing the invocant in base $base (only parameter); Fails if $base is smaller than 2 or larger than 36

before (generic comparison) - generic comparison operator used by the Order class, True when left should precede right

> (predefined subrule) - negative zero-width lookahead, if after this position follows the given pattern inside the angle brackets, the whole pattern will not match

> (predefined subrule) - positive zero-width lookahead, only if this position is followed by the given pattern inside the angle brackets, the whole pattern will match

BEGIN (closure trait) - marks as a prefix a special block or statement, executed at compile time, ASAP, only ever runs once

Bit (immutable type) - Perl single bit (allows traits, aliasing, undef, etc.)

(predefined subrule) - a single "blank" character -- in most locales, this corresponds to space and tab

bless - calling bless on any invocant (but typically a type object) to create a new object with the same class as the invocant

Blob - (immutable type) - An undifferentiated mass of bits

Block (immutable type) - Executable objects that have lexical scopes (enclosed by curly brackets)

&?BLOCK (special var) - reference to current block

Bool (immutable type) - Perl boolean, type of values that can be either True or False which is in full length Bool::True and Bool::False

break (flow control) - leave this when block now, see also: last and leave

Buf (mutable type) - Perl buffer (a stringish array of memory locations), type for raw binary data

but - adds a role to a class

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() (regex modifier) - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":continue"

\C[] (escape sequence) - any character except the bracketed named or control character

\c[] (escape sequence) - named character or control character

|c (escape sequence) - codepoint boundary, zero width space between two unicode codepoints, see also: |g and |w

cached (routine trait) - marks a subroutine as being memoized

call - execute a subroutine

caller - object describing the callable (routine) from which as routine was invoked

callframe - returns an object that describes a particular callframe as described by a list of matchers

callwith - callable-method 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) - type holding arguments for a routine call (right-hand side of a binding)

cat (array method) - converts values of a list into string context and joines them like with ~, alias to .join('')

CATCH (closure trait) - marks as a prefix a special block to catch Exceptions, before LEAVE

categorize (array method) - special form of map to classify a list values (values - optional second parameter), with a closure (mapper - first parameter); the return value of the closure determines, under which key the value appears in the resulting hash, unlike classify the return value of the mapper can be listref to put the value in several categories or Nil to reject the value for categorisation

category (grammatical category) - grammatical category of all grammatical categories (metacategory), useful in case you want to create a new one with a macro

ceiling - lowest integer not less than $x (only parameter)

chr (num method) - convert number into character according a character table (UTF), reverse of ord

chrs (num method) - plural of char, takes a list of Int and returns a Str, reverse of ords

chars (string method) - returns number of characters of a string, was length in Perl 5

:chars (regex modifier) - searching on character level (default), see also: :bytes, codes, graphs

chdir - changes the current working directory ($*CWD)

CHECK (closure trait) - marks as a prefix 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 (from only parameter)

chop (string method) - returns a string with the last character removed (from only parameter)

chown - changes owner of files

chroot - change root directory on POSIX systems

circumfix (grammatical category) - operator namespace of two parted ops that surround the statement, op or variable they affect, most prominent example may be the double quotes

class (block modifier) - following block will build an object, see also method, submethod and has

$?CLASS (special var) - current class object

::?CLASS (special var) - name of the current class

classify (array method) - special form of map to classify a list values (values - optional second parameter), with a closure (mapper - first parameter); the return value of the closure determines, under which key the value appears in the resulting hash, classify { chr $_ }, 97..99 returns {"a" => [97], "b" => [98], "c" => [99] } , values are always listrefs (see also categorize)

close (filehandle method) - releasing the connection to a file via a file handler

:closure (quoting adverb) - forces evaluation of closures (blocks aka {...}) inside quotes, long form of :c, included in "...", qq/.../ and <<...>>

cmp (generic comparison) - general infix sort comparator, result is Order::Increase (numerically -1) if before is True - Order::Same (numerically 0) if eqv - Order::Decrease (numerically 1) if after, see also: leg and <=>)

(predefined subrule) - a not visible character that is aimed to control the console output

code (context op) - forces callable context, alias to &()

:code (quoting adverb) - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: quasi

: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(rx/.../) aka m/.../, default pattern is rx/./

@=COMMENT (special var) - all the comment blocks in the file

Complex (immutable type) - Perl object type to hold a complex number

conjugate - convert complex number into real (Num), see also abs

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

continue (flow control) - makes execution in a 'given' also try the following 'when' clauses

:continue() - (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 as a prefix a special block to catch control Exception (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")

cos (numeric op) - cosine, trigonometric function, takes angle in radians; see also to-radians, sin, tan

count (routine method) - returns how many parameters this routine takes (including optional), .arity counts just the required

cross (list method) - alias to X operator - example: @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(&[~]) }

$*CWD (special var) - current working directory as Str

D

:d (filetest op) - check if file is a directory

\D (escape sequence) - a single nondigit character

\d (escape sequence) - a single digit character

$=data (special var) - handle for the data block (=begin data ... =end data), use $=data.lines to iterate over the lines of it

decode (Buf method) - transforms raw binary UTF (Buf) into readable UTF Text (Str)

default (block modifier) - following block will be run if no when clause in surrounding block matched

defer (block modifier) -

defined - scalar method tests whether a value has been assigned to a variable

delete (array method) - removes all values of which indices are passed

delete (hash method) - removes all pairs of which keys are passed

denominator (rat method) - returns the denominator of a rational number (value type Rat and FatRat)

die - throws a fatal Exception, the default exception handler print's each element of the list to $*ERR

(predefined subrule) - single (decimal) digit char aka \d

dir - returns all files of a given directory, excluding . and .. by default

$*DISTRO (special var) - running OS distribution, you might want to use $*DISTRO.name, see also: $*KERNEL and $*VM_

$?DISTRO (special var) - OS distribution the program was compiled for, see also: $?KERNEL and $*VM

div - integer division

do - executes a block (do once loop)

does - checks if an objekt inherits a role (parameter)

dotty (grammatical category) -

: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 (compute all values now), default for scalars - not for lists

$*EGID (special var) - effective global ID of the running process ($*PID) owner, was @) and $EGID in Perl 5

elems (array op & method) - number of elements (values), see also: end

elems (hash op & method) - number of pairs

else (block modifier) - introduces the alternative block after an if or elsif, that is executed, when conditions of all alternatives resulted in false, see also default

elsif (block modifier) - alternative if clause

encode (Buf method) - transforms readable UTF Text (Str) into raw binary UTF (Buf)

END (closure trait) - marks as a prefix a special block, executed at run time, ALAP, only ever runs once

end (array op & method) - last index of that list, see also: elems

ENTER (closure trait) - marks as a prefix a special block or statement, executed at every block entry time, repeats on loop blocks

Enum (immutable type) - An immutable Pair

enum - enum takes a list of keys or pairs and adds values to any keys that are not already part of a pair (one more than the previous key had) - example: %hash = enum <<:Mon(1) Tue Wed Thu Fri Sat Sun>>;

EnumMap (immutable type) - A mapping of Enums with no duplicate keys

%*ENV (special var) - environment variables (of the shell), was %ENV in P5

eq (comparison op) - infix operator, proves equality in forced string context as does = in numeric context

equiv (routine trait) - specifies the precedence of an operator same as an existing operator

eqv (comparison op) - infix operator, compares the dynamic state of objects and values, in contrast with static =

err (logical op) - short circuit defined or, returns the first defined value from the left, short circuit or,low precedence version of //

$*ERR (special var) - standard error output (command line mostly), STDERR in Perl 5

$*EUID (special var) - effective user ID of the running process ($*PID) owner, was @> and $EUID in Perl 5

eval - just compiles a string and runs it, returns a result and maybe error message in $! but does not catch Exceptions, second optional parameter defines a parser grammar which should understand the string

evalfile - eval a file like 'do' did in Perl 5, with optional second parameter, which is a grammar that can parse that file

: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 evaluated as Perl code (like eval) replaced with its result, alias to Q :x and qx/.../

$*EXECUTABLE_NAME (special var) - name of the main scripts file name, was $0 in Perl 5

: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, array or hash member, scalar method

exit (flow control) - stops all program execution, and returns Int $status (first parameter) to the calling environment

exp - exponentiate, alias method to: $base (first parameter) ** $exponent (second parameter - defaults to e)

export (routine trait) - this routine will be exported by the current module by default

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 the &-sigil 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 - causes the routine to return an unthrown Exception, if use fatal; is in effect where the routine was called from, it throws the exception

Failure (undefined value type) - data type object for an error, thrown by an unhandled Exception

False - boolean value aka Bool::False, 0 in numeric context, '' (empty) in string context

FatRat (immutable type) - Perl rational (unlimited precision in both parts)

ff (conditional op) - tests $_ against two values, flip flop operator in the style of awk, can test the right operand and become False on the same evaluation it became True, formerly .. in scalar context

fff (conditional op) - tests $_ against two values, flip flop operator in the style of sed, after became True ($_ is larger then left value), right side will be tested during next loop iteration, formerly ... in scalar context

$?FILE (special var) - current filename of source file

FIRST (closure trait) - marks as a prefix a special block or statement, executed at loop initialization time, before any ENTER

first (array op & method) - returns first value of a list that passes a condition (first paramter); the condition is a closure that takes one value at a time (as $_ or $^a); works like grep - example : first {$_ %% 2}, 1..5; # returns 2

flat (context op) - forces flat list context, opposite of lol - example: ([2,3],[4,5]).flat or flat([2,3],[4,5]) results in: [2..5]

flip (string method) - reverses order of characters in string, see also: reverse and invert

floor (num method) - Int (whole number) part of a Rat, just leaves the digits after the dot (".") out

fmt (formater) - variable method for simple printf - like formating, takes a format specifier and returns a string, format specifier accepts only 1 value placeholder, in case of a hash max. 2; second, optional parameter is delimiter between values or pairs (in case of a hash);

for (block modifier) - loop that only iterates over the following list and sets $_ for each iteration (contextualizer), see also: given

fork - creates a copy of the current process and returns in the original process a Proc object of the child (0 in num context) and in the child a proc object of the original (process ID in num context)

from-radians - convert from radians to $base (second parameter), opposite of to-radians

:function (quoting adverb) - demands evaluation of functions (subs and methods), that start with the &-sigil and replacing them with the result, long form of :f , included in "...", qq/.../ and <<...>>

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

|g (escape sequence) - grapheme boundary, zero width space between two unicode graphemes, see also: |c and |w

gcd (numeric infix op) - greatest common divisor (see also: lcm)

gather (block modifier) - performs the following block once, returns a list of all values passed by take

ge (infix string comparison) - greater than or equal, see also gt and le

get (handle method) - returns a line (item context) or all lines (list context) from that input stream like a file or command line

getc (handle method) - reads one character from a file via file handle

getlogin - returns the username of the account running the program, maybe less secure as getpwuid

gethost - establish a connection to a net host and retrieve information

$*GID (special var) - real global ID of the running process ($*PID) owner, was @( and $GID in Perl 5

gist (formater) - generates a Str with the essential content of that object for human consumption (like in error messages), Mu will foreward to .perl

given (block modifier) - part of a case-like construct, puts the following value into the context variable (thatswhy called contextualizer) for when clauses, see also for

:global (regex modifier) - searching for any finding (not just the first), long for :g

goto (flow control) - continue execution on a defined label (with "name:")

grab (hash method) - random selection of hash keys, weighted by its related values, grabbing a key decrements its value (local copy) by one (deleting key when it goes to 0), see also pick ans roll

grabpair (hash method) - random selection (only parameter) of hash pairs, (each pair only once) , see also pick ans roll

grammar - special kind of class with methods that execute regex, token and rule

$?GRAMMAR (special var) - grammar of the currently used language (mostly $~MAIN)

(predefined subrule) - a "graphical" character

:graphs (regex modifier) - searching on the level of language-independent graphemes, see also: see also: :bytes, chars, :codes

grep (array op & method) - returns all values of an array that pass a filter condition (first parameter); the condition is a closure that takes one value at a time (as $_ or $^a); see also first - example : grep {$_ %% 2}, 1..5; # returns 2 4

gt (string comparison) - infix operator, greater than or equal, True if alphabetically ordered the right comes before the left (see also lt, leg and <)

H

:h (quoting adverb) - demands evaluation of hash variables that start with the %-sigil, long form of :hash, included in "...", qq/.../ and <<...>>

\H (escape sequence) - anything but horizontal whitespace char

\h (escape sequence) - horizontal whitespace char, part of \s

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, see also class

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 (context op) - enforces hash-list context, alias to %()

:hash (quoting adverb) - demands evaluation of hash variables that start with the %-sigil, 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) - get an instance the objects metaclass, its "Higher Order Workings"

hyper - forces none-lazy list context, that ignores the order of results (allows 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) - if the following expression evals to True, the block after that will be run, opposite of unless, can also be written at the end of an expression

: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

import - just import definitions from an already loaded module (see use and need)

$*IN (special var) - standard input (command line mostly), see also $*OUT

@*INC (special var) - include pathes (but not for standard library modules), formerly @INC

index (string method) - finds the first occurrence of a substring in a string and returns the numerical position, opposite or rindex

Inf - indicates infinity, useful to generate infinite lazy lists, does in most context same as *

infix (grammatical category) - namespace of symbols that stay between two statements, that become their parameters - example: $a + $b # is same as $a.&infix:<+>($b)

infix_circumfix_meta_operator (grammatical category) - internal namespace of metaoperator that circumfix other operator but stay infix (between) two terms (mostly lists) - example (the arrows): _ @a <<+<< @b_

infix_postfix_meta_operator (grammatical category) - internal namespace of metaoperator that postfix other operator but stay infix (between) two terms - example (equal sign): _ $a += 5_

infix_prefix_meta_operator (grammatical category) - internal namespace of metaoperator that prefix (precedes) other operator but stay infix (between) two terms - example (exclamation mark): _ 4 != 5_

INIT (closure trait) - marks as a prefix 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, objext type to hold whole number like -1, 2 or 6000, allows Inf / NaN, arbitrary precision, use it as method to convert into a Int like the Perl 5 "int"

invert (hash op & method) - inverts the key => value relation of a pair or a series of pairs (hash), returning a Pair list, see also reverse and flip

IO (mutable type) - Perl filehandle

is - bind a traits to a variable

item() (context op) - forces scalar context, alias to $()

Iterator (mutable type) - Perl list

J

join (array method) - concatenates list elements into a string, optionally inserting another string between the elements - example: join("-", 1..5) # returns '1-2-3-4-5' - or (1..5).join("-")

K

:k (filetest op) - report if file has sticky bit set

KEEP (closure trait) - marks as a prefix a special block, executed at every successful block exit, part of LEAVE queue

:keepall (regex modifier) - forces subrules to memorize everything (even comments)

$*KERNEL (special var) - (core or type of the) running operating system, use $*KERNEL.name instead of Perl 5s $OSNAME, see also: $*DISTRO and $*VM_

$?KERNEL(special var) - kernel (core operating system) the program was compiled for, might want to use use $?KERNEL.name, see also: ?*DISTRO and $?VM

key (pair method) - gives the key part of a pair, opposite of value

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 (array op & method) - returns the list array indexes

keys (hash method) - returns list of hash keys

kill - sends the given $signal to the process(es) given and returns a boolean value indicating success (True)

kv (hash method) - returns list of key-value pairs

L

:l (filetest op) - file is a symbolic link

\L[] (escape sequence) - everything within the brackets is lowercase

$*LANG (special var) - LANG variable from %*ENV that defines what human language is used

%?LANG (special var) - current set of interwoven languages

LAST (closure trait) - marks as a prefix 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 (calculate values as late as possible), default for lists - not scalars

lc (string op & method) - make string lowercase

lcfirst (string op & method) - make first char of a string lowercase

lcm (numeric infix op) - least common multiple, see also: gcd

le (string comparison) - infix operator, result is True if left side is lower than or equal than the right, see also: lt, gt and ge

LEAVE (closure trait) - marks as a prefix a special block, executed at every block exit time

leave (flow control) - exit the current block with a return value

leg (string comparison) - general infix sort comparison operator in string context, leg stands for lower/equal/greater, cmp is the more general form, <=> does same in numerical context, was cmp in P5

let - changes value of a variable temporary, it will be set back if the current block exits unsuccessfully

$?LINE (special var) - current line number

lines (string & iomethod) - returns a chomped list of lines (chunks of character separated by \n) containing a string - example: $str.lines($limit) equals $str.comb( / ^^ \N* /, $limit ), works also on file handles

list() (context op) - almost a no-op, just makes sure that $item (first parameter) can be iterated, alias to @(), see also flat and lol

log - logarithm of $x (first parameter) to the $base (second optional parameter - default is e, together also known as ln )

log10 - logarithm to the base of 10, also known as lg on calculators

lol (context op) - forces list of list context on a value, meaning a list which values are not contextualized further (can be lists themthelves), opposite of flat

loop (block modifier) - general loop, can serve as enless loop without following term of C-style loop - example: loop my $b=1; $b++; $b<5 {...}

looser (routine trait) - specifies the precedence of an operator lower than an existing operator

(predefined subrule) - a single lowercase character

lt (string comparison) - infix operator, lower than, True if alphabetically ordered the left comes before the right

M

m// (regex quoting op) - perform a regex based search in place (m stands for match ), similar to match-method

: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 (routine type) - define a routine to alter source code at compile time

$~MAIN (special var) - current grammar of main language, tells the parser the rules of parsing Perl

map (array op & method) - take a list, perform a block on each member, return a list of the results - example: say map { chr $_ }, 66..69 (is "B C D E") or say map { chr $_ }, 66..69

Match (mutable type) - Perl match object, usually produced by applying a pattern of regular expression to a string

match (string method) - method alias to m/.../, $str.match( /
/ ) equals $str ~~ m/
/;, returns a match object that end up also in $/

max (array op & method) - returns the numerically largest value from a given list

maybe (block modifier) -

Method (mutable type) - Perl method

method (routine type) - 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

mkdir - creates a directory with given name

mod (numeric op) - integer modulo operator; wordy alias to % - example: 5 mod 4 = 1;

module (block modifier) - introduces a module name, a package that performs special actions on loading

&?MODULE (special var) - reference to the current module

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) - an unicode newline character, its \u000A | \u000B | \u000C | \u000D | \u0085 | \u2028 | \u2029 | \u000D\u000A

:nd (regex modifier) - demands the nth finding (:2nd), has many aliases (:st :rd :th) for correct spelling

name (routine method) - returns the name of of a routine, handy when it was stored in a scalar

need - just load a module, without import definitions (see use and import)

new - creates a new object of a class(as in most other languages), also name of the automatically called constructor method

NEXT (closure trait) - marks as a prefix a special block, executed at loop continuation time, before any leave

next (flow control) - start the the next following loop iteration

nextsame - get from the dispatcher the next candidate with the same signature, similar to javas SUPER

Nil (undefined value type) - unlike undef in Perl 5 it really means no value here - example: @a = Nil, Nil; # array has zero elements

none (junctive op) - return True when a value is not part of a set, junctive NOT operator

normalize - (string method) - normalize (repair) Unicode (UTF) string

not (context op) - logical NOT operator, converts to boolean context which means it returns False if value is positive or otherwise, low precedence version of !()

note - makes output via command line ($ERR) like warn, but appends a newline (\n) like say

Num (immutable type) - Perl number (approximate Real, generally via floating point)

numerator (rat method) - returns the numerator of a rational number (value type Rat and FatRat)

O

:O (filetest op) - tests if file is owned by real uid

:o (filetest op) - tests if file is owned by effective uid

of (routine trait) - inner type constraint that a routine imposes on its return value - example: subset Month of Int where { 1 <= $^a <= 12 }

one (junctive op) - junctive XOR operator, True if only one expression (of a following list) is true in bool context, see also: |

only routine modifier - permits only one routine of the same name in this block

open (path method) - establishes a connection to a file via a file path name file handler

$*OPTS (special var) - options from command line

or (logical op) - short circuit OR, evaluates sequentially, ends evaluation at the first expression that returns True, low precedence version of ||, similar to orelse

ord (string method) - converts a character into number according a character table (Unicode), reverse of char

ords (string method) - plural of ord, takes a Str and returns a list of Int, reverse of chars

orelse (logical op) - logical OR short circuit operator, transferring an error code from first to second block/command, if first do not succeed, similar to //, see also andthen

our (scope declarator) - introduces package - scoped names for variables and routines

$*OUT (special var) - standard output (command line mostly), see also $*IN

: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 $*KERNEL with Q :p /.../, short for :path

:p() (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

$~P5Regex (special var) - current grammar of the Perl 5 compatible regular expression language

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

&?PACKAGE (special var) - reference to the current package

package_declarator (grammatical category) - internal namespace for - example: package, module, class

Pair (mutable type) - object to hold a single key-to-value association

pairs (hash method) - returns all contents as an array or pairs (key,value)

PairSeq (mutable type) - a Seq (sequence) of Pairs

:panic (regex modifier) - overwriting a possible set :ratchet for all subrules (activates backtracking)

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

:path (quoting adverb) - quote paths and create path object that know the right format of the current $*KERNEL with Q :path /.../, long for :p

perl (formater) - transforms data structure into Perl 6 source syntax; use eval onto that string and you get the data structure again, bit like Data::Dump

$*PERL (special var) - Perl version running under, was $] and $^V in Perl 5

$?PERL (special var) - Perl version compiled for

:Perl5 (regex modifier) - activate old Perl 5 regex rules, alias to :P5

pick (array op & method) - select a number (first parameter) of random vaues (without duplication), take roll to enable duplication

$*PID (special var) - ID of the running process, was $$ and $PID in Perl 5

phaser - Perl 6 term for specially named subblocks withe special runtimes aka closure traits - example: BEGIN

pick (array method) - selects randomly elements from this list, optional parameter says how many

$=pod (special var) - surrounding POD object

polar - magnitude or angle corresponding to the complex number (only parameter), the magnitude is non-negative, and the angle in the range -π ..^ π

pop (array op & method) - removes and returns the last element in an array

:pos() (regex modifier) - searching only on the th position (counting from 0), long for :p

POST (closure trait) - marks as a prefix 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 - example(square brackets): $a[2]

postfix (grammatical category) - operator namespace of ops, that stay after a statement or variable (like $a++)

postfix_prefix_meta_operator (grammatical category) - internal namespace of metaoperator that prefix (precedes) other operator but stay postfix (after) another term - example (greater as): @a >>++

PRE (closure trait) - marks as a prefix a special block, assert precondition, executed at every block entry, before ENTER

pred (sequence traversion) - returns the predecessor of $x (only parameter), alias to -- operator, see also succ

prefix (grammatical category) - operator namespace of ops, that stay before a statement or variable - example: ++$a

prefix_circumfix_meta_operator (grammatical category) - internal namespace of metaoperator that circumfix (surrounds) other operator but stay prefix (before) another term - example (square brackets): [+] @a # sums up all elements of @a

prefix_postfix_meta_operator (grammatical category) - internal namespace of metaoperator that postfix other operator but stay prefix (before) another term - example (greater as): ++<< @a

print - sends characters to an output stream ($*OUT) without adding a newline, similar to say

print (handle method) - writes a stream into a file

(predefined subrule) - a single printable character

printf - formats text like sprintf and sends it to standard output like print

- standard grammar's rule for whatever the prior successful regex matched

prompt - print - ing text and reading a line from $*IN

proto (routine modifier) - fallback for multi, if no multi routines signature matches the callers, a proto with same name is executed

(predefined subrule) - a single punctuation character

push (array op & method) - appends a list of values to the end of an array (see also pop)

push (hash op & method) - inserts a list of pairs in a Hash; if a key already exists, it will point to an array of both values

Q

Q (quoting op) - most basic quoting operator, understands a list of adverbial modifier

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[] (escape sequence) - all metacharacters within the brackets match as literal characters

qp (quoting op) - path quoting, quoted string will be evaled as an file or directory path, alias to Q :p /.../ and Q :path /.../

qq (quoting op) - double quoting, q with interpolation of variables, closures, and special chars, 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 and blocks, alias to "...", qq/.../ and Q :s, :a, :h, :f, :c, :b /.../, short for :double

qqx (quoting op) - run as system call and return results; was qx/.../ in Perl 5

$~Quasi (special var) - current grammar of the quasiquoting language

quasi (block modifier) - quasi quoting, the following commented will be compiles and the AST will be returned as result, see also: :code

$~Quote (special var) - current grammar of the quoting language as used by the Q-operator and any other quoting op

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 into words (on whitespaces) but with quote protection (like in shell - '...' and "..." sourrounded strings are taken as single words), long form of :ww, used in <<...>>

qw (quoting op) - splits result on words (as in Perl 5); alias to Q :q :w /.../ or <...>

qx (quoting op) - evaluate as Perl term (like eval) and return results (unlike Perl 5), alias to Q :x /.../ or Q :exec /.../

R

: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

R (meta op) - reverse operands - example: 4 R- 3 # result is -1 = 3 - 4

rand - pseudo random number in range 0 ..^ 1 (including 0, but not 1); for random list choices see pick and roll

Range (immutable type) - a pair of ordered endpoints, result of an evaluated term with the range operator

RangeIter (mutable type) - iterator over a Range

Rat (immutable type) - Perl rational number (exact Real numerator, limited denominator)

:ratchet (regex modifier) - deactivates backtracking, search starts at pos, where last match ended

:rd (regex modifier) - demands the nth finding, has many aliases (:st :nd :th) for correct spelling (:3rd)

read (Buf method) - read n (first parameter) bytes from a buffer

readline -

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(&[+])

Regex (mutable type) - builtin type that holds a compiled regular expression

regex - (routine type) - a pattern definition (without :ratchet and :sigspace), can be put in a grammar, similar to qr/.../ in Perl 5, see rule, token

:regex (quoting adverb) - parse as quoted string as regex

$~Regex (special var) - current grammar of the regex language as used by rx and any regex operator and method, tells the parser how to parse regular expressions

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 (block modifier) - can be put before a block so that while or until can be written after the closing bracket, these loops will always run at least one time because the condition will be checked after each run

rename - changes names of files and directories

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

rmdir - deletes a directory with given name

role - container for methods that can extend a class using does

$?ROLE (special var) - current role object

::?ROLE (special var) - name of the current role

roll (array method) - selects (first parameter) values from an array, duplication can occur (like rolling dice), pick works without duplication

roots - (Num $f, Int $n) compute the $n'th root of $f

rotate (array method) - put some elements (number is first parameter) of a list to the end; rotates backward with negative parameter; @a .= rotate;_ is alias to _@a.push: @a.shift;

round - returns the nearest integer of only parameter

roundrobin (array method) - kind of zip that ignores empty lists - example: roundrobin([1..3],[1,2],[1]) = 1,1,1,2,2,3

&?ROUTINE (special var) - current Routine object

routine - block of code callable by name, can have a signature and a return type, objects of the type SoftRoutine and HardRoutine

routine_declarator (grammatical category) - internal namespace for routine declarators - example: sub, method

rule (routine type) - alias for regex :ratchet :sigspace in a grammar, see regex, token

run - executes an external program, and returns control to the caller once the program has exited

runinstead - executes an external program that replaces the caller, because there will be no return

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 (routine type)

S

S (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() (string method)

:S (filetest op) - file is a socket

:s (filetest op) - file has size greater than 0 (zero)

:s (quoting adverb) - demands evaluation of scalar variables that start with the $-sigil, 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, ms/.../ is alias to m:sigspace/.../

\S (escape sequence) - anything but whitespace

\s (escape sequence) - any whitespace character, horizontal ( \h ) and vertical ( \v )

(predefined subrule) - match the zero-width space between two identical chars

: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/.../.../ - example: ss/teh hsa/the has/;

say - makes output via command line ($*OUT) like print, but appends a newline (\n)

say (handle method) - writes a stream into a file and appends \n

Scalar (mutable type) - object to hold a Perl scalar, a variable for a single value

:scalar (quoting adverb) - demands evaluation of scalar variables that start with the $-sigil, long form of :s, included in "...", qq/.../ and <<...>>

scope_declarator (grammatical category) - internal namespace for scope declarators - example: my, our, has, state

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

set (array op & method) - creates a Set

sigil (grammatical category) - word to name the namespace for sigils, used to redifine them or define your own with a macro

sigil}*

sign - 1 when $x (only parameter) > 0, -1 if < 0, 0 when = 0, undefined when undefined

Signature - (immutable type) - object type to hold all information a signature like parameter types and values, return type, etc.

signature (routine method) - returns a capture object with the signature of this routine

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, ms/.../ is alias to m:sigspace/.../

sin (numeric op) - sine, trigonometric function, takes angle in radian; see also to-radians, cos, tan

:single (quoting adverb) - simple quoting (slashes and '), alias to '...' and q/.../, long for :q

sleep - attempt to sleep (stop the program) for up to (only parameter) seconds (with sub-second resolution)

slang - sublanguages of Perl 6, their grammar is mostly stored in special variables with the twigil ~, such as $~Regex or $~MAIN (main language); you can change or alter them with this keyword by using the augment or supersede command

slurp (path|file handle method) - reads an entire file into a string without a file handle

so (context op) - converts value into the boolean context, low precedence alternative to ?

SoftRoutine (mutable type) - routine that is committed to staying mutable

(predefined subrule) - single white space char aka \s

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 (formater) - inserts formated values out of variables into a string like printf, but returns the string instead of outputting it

sqrt - square root of $n (Num - first and only parameter)

ss/// (regex quoting op) - performs rx based substitution, spaces are just subrule separators, alias to s:ss/.../.../, 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

:st (regex modifier) - demands the nth finding, has many aliases (:nd :rd :th) for correct spelling (:1st)

START (closure trait) - marks as a prefix 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)

stat (filetest op) - available information about a file or link (call stat :link as former lstat)

state (scope declarator) - introduces lexically scoped but persistent names (known only in the enclosing block, but retain their values between invocations)

statement_control (grammatical category) - internal namespace for block modifier like conditionals or loops that stay in front of it

statement_mod_cond (grammatical category) - internal namespace for words that come after a statement and handle if the statement will be executed - example : $a++ if $a > 3

statement_mod_loop (grammatical category) - internal namespace for special group of block modifier that turn the block into a loop - example : loop, repeat, for

statement_prefix (grammatical category) - internal namespace for block modifier - example : do

Str (immutable type) - Perl string, finite sequence of Unicode characters

Sub (mutable type) - Perl subroutine object

sub (routine type) - defines a subroutine, a block callable by name - example: name();

Submethod (mutable type) - Perl subroutine acting like a method

submethod (routine type) - defines methods, not inherited by subclasses

subset - define a subtype, eg subset Month of Int where { 1 <= $^a <= 12 }

subst (string method) - method alias to s/.../.../, $str.subst( /pattern/, "replacement" ), equals $str ~~ s/pattern/replacement/;

:subst (quoting adverb) - parse as substitution regex, Q :subst /.../.../ is alias to s/.../.../

substr (string method) - the scalar substring function like in Perl 5

succ (sequence traversion) - returns the successor of $x (only parameter), alias to ++ operator (see pred)

supersede (scope declarator) - replaces definitions of an existing name, e.g. methods and attributes of a class or grammar, see also: augment

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 - can add several item to the list of return values of a gather block

tan (numeric op) - tangent, trigonometric function, takes angle in radian; see also to-radians, cos, sin

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

: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

to-radians - convert from $base (second parameter) to radians, opposite of from-radians

token (routine type) - regex method without backtracking, alias to regex :ratchet , part of a grammar , see also rule

touch (filehandle method) - update timestamps on a file (like the Unix command)

tr/// (quoting op) - transliteration (as in Perl 5), translating some character in a string into others, alias to Q :trans /.../.../

trait_auxiliary (grammatical category) -

trait_verb (grammatical category) - example : of

:trans (quoting adverb) - evals the quoted as transliteration aka tr /.../.../ aka .trans("..." => "...")

trans (string method) - method name for tr/.../.../ operator, $str.trans( %mapping ) equals $str ~~ tr/%mapping.sort.keys/%mapping.sort.values/;

$~Trans (special var) - current grammar of the transliteration language (used by trans() aka tr/.../.../)

triangle (list method) - alias to [\ ] metaoperator - example: [\+] @a = @a.triangle(&[+])

True - boolean value aka Bool::True, 1 in numeric context

truncate (num op) - closest integer to $f (only parameter) whose absolute value is not greater than the absolute value of $f

trusts - allows a class the acess to otherwised sealed namespaces

twigil (grammatical category) - internal namespace for twigils, used to redifine them or define your own with a macro

type_declarator (grammatical category) - - example: subset

$*TZ (special var) - local time zone

U

:u (filetest op) - report if file has setuid bit set

\U[] (escape sequence) - everything within the brackets is uppercase

uc - make all string chars uppercase

ucfirst - make first char of a string uppercase

$*UID (special var) - real user ID of the running process ($*PID) owner (user), was @< and $UID in Perl 5

UNDO (closure trait) - marks as a prefix a special block, executed at every unsuccessful block exit, part of LEAVE queue

uniq (list method) - only unique elements of a list

unless (block modifier) - if the following expression evals to False, the block after that will be run, can also be written at the end of an expression, opposite of if

until (block modifier) - runs block repeatedly as long as the following expression evals to False, can be combined with repeat, can also be written at the end of an expression, opposite of while

unwrap - remove an enclosing subroutine, see also: wrap

(predefined subrule) - a single uppercase character

uri - returns IO::Streamable descendant for accessing content of that URI (only pramameter typed Str)

$?USAGE (special var) - default usage message generated at compile time

use - load a module, check Perl version, import definitions (see need and import)

V

\V (escape sequence) - anything but vertical whitespace

\v (escape sequence) - vertical whitespace character (LF | CR | FF | Line Tab | Next Line | Line Separator | Paragraph Separator), see also: \s (whitespace)

value (pair method) - gets value (second) value of a pair (opposite of key) - example: (key => 'value').value; # returns 'value'

values (array op & method) - returns an array of values like the var itself in list context does

values (hash method) - returns an array of just the values - example: (1 => 2, 3 => 4).values; # returns (2,4)

$*VM (special var) - running virtual machine, might want to use $*VM.name, see also: $*DISTRO and $*KERNEL

$?VM (special var) - virtual machine the program is compiled for, see also: $?DISTRO and $?KERNEL

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 "_")

|w (escape sequence) - word boundary, zero width space between two \w, alias to , see also: |c and |g

wait - waits for a child process to terminate and returns the child status object, process ID in numeric context

warn - makes output via standart error output ($ERR - usually the command line), similar to note, but works more like print, without appending \n

(predefined subrule) - zero-width word boundary between an \w and a \W character aka \b, alias to |w, see also

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), alias to *

WHEN (introspection method) - (reserved for events?)

when (block modifier) - executes its following code block, when parameter matches against $_ (set by given or for), see also: default

WHENCE (introspection method) - autovivification of closures

WHERE (introspection method) - memory address of the object

where - defines subtypes of data - example: subset Month of Int where { 1 <= $^a <= 12 }

WHICH (introspection method) - object ID (type)

while (block modifier) - runs block repeatedly as long as the following expression evals to True, can be combined with repeat, can also be written at the end of an expression, opposite of until

WHO (introspection method) - package, that support that object, long name in string context

WHY (introspection method) - reserved for documentation, see also #=

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 (string method) - splits a sting into a list of words - example: $input.words($limit) equals $input.comb( / \S+ /, $limit )

:words (quoting adverb) - split quoted string on words (on whitespaces), no quote protection, long form of :w, used in qw/.../

wrap - creates enveloping subroutine (see also unwrap)

write (Buf method) - writes content of all parameter into that buffer

(predefined subrule) - whitespace between words aka \s*

:ww (quoting adverb) - split quoted string into words (on whitespaces) but with quote protection (like in shell - '...' and "..." sourrounded strings are taken as single words), short form of :quotewords, used in <<...>>

(predefined subrule) - zero-width space inside of a word between two \w character, see also

X

X (list op) - Cross product of two arrays, alias of cross method - example: 1,2 X 3,4 == 1,3,1,4,2,3,2,4;

x (string op) - string replicate operator to single string - example: 'ab' x 3 == 'ababab';

X (meta op) - Cross product with hyper operator, alias of crosswith method - example: X~ == ;

: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 evaluated as Perl code (like eval) and replaced with its result, alias to Q :exec /.../ and qx/.../

:x() (regex modifier) - searching n times (n is an int) with this pattern

\X[] (escape sequence) - anything but the character given in hexadecimal (brackets optional)

\x[] (escape sequence) - character given in hexadecimal (brackets optional)

(predefined subrule) - single hexadecimal digit char

xor (logical op) - infix logical eXclusive OR operator (XOR), True if only one side has positive value, returns otherwise left value, low precedence version of ^^

xx (infix list op) - replicate a list $n (second operand) times - example: 'ab' xx 3 =

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, joines 2 lists and stops when 1 list runs out of elements, returning always an list with an even length - example: 1,2,3,4 Z 8,9 == 1,8,2,9

Z (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 - example: @a Z @b = (@a; @b).zip

zipwith (list method) - alias to Z metaoperator - example: @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 | U | V | W | X | Y | Z

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

Perl 6: Perl 6 Index Tablet

Perl 6 Index Tablet