Intro    Chapter:   0. History   1. Design   2. Basic   3. Var   4. Op   5. IO   6. Block   7. Sub   8. OOP   9. Regex   10. Meta
Overview   Appendix:   A. Index   B. Grouped   C. Classtree   D. Delta   E. Exciting   F. FAQ   G. Glossary   H. Href

This is an alphabetic sorted list of all operators, methods, builtins, types, modifier and special variables with short explanations, cross references, alternative syntax, code examples and Perl 5 equivalents. It is sorted (almost as decided by leg) without prefixes like colon, dot, backslash, sigil or twigil and everything that contains punctuation or number comes first. Sometimes a green placeholder is added: n stands for a integer number, f is a floating point number, c a single character, s string, var any variable, p a regex pattern, l a list, r a range, op any operator, x any expression, t any term. After each method is its signature (in round brackets), telling you the value type (same as in placeholders) of the parameters and the return value. Each item is linked to a more detailed explanation inside of a tablet. Each term is followed by a link «in french brackets» to a condensed summary of its category in Appendix B or to the relevant category in the tablets. Most links in the short description lead to another item in A (when bold) or to the glossary (when italic). The chapter headlines serve as anchor and links to the navigation menu. Thats why large chapter like C are split into "C" (second letter a-m) and a following "n" (second letter n-z).

Navigation: ! " # $ % & ' ( * + , - . / 0 : ; < = > ? @ [ \ ^ _ { | ~

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

Punctuation

! «context op»prefix 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

!op «meta op» — negates (mostly comparison operators)

$! «special var» — last error message

! «regex metachar» — a leading ! in a subrule a negative zero-width assertion like *, opposite of ?

<!> «predefined subrule» — opposite of <?>, returns always False

!! «conditional op» — just second part of the ternary (conditional) operator after ??, no operator 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» — matches the end of a line (no more multile mode)

%

% «sigil»prefix of hash variables

% «numeric op» — infix modulo operator, gives remainder of a Int division, forces numeric context, high precedence version of mod — example: 5 % 4 returns 1

%() «context op» — forces hash context, alias to the hash() function

%s «regex metachar» — quantifier that repeat char or group as long as separated by right expression — example: \d % ',' matches 1,2,3,4,5 — see also: %%

%% «numeric op»True if the left value is evenly divisible by the right value — see also: %

%%s «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»infix short circuit logical AND, evaluates sequentially left to right its operands until one is False in boolean context, if one was False the result in boolean context is False, otherwise the last evaluated operand, high precedence alias of and — example: 0 and 7 returns 0 — see also: &

' ' «quoting op» — simple quoting, just / and ' must be escaped, alias to q/.../ or Q :q/.../

( ) — grouping of values (parameters) to a Parcel

( ) «regex metachar» — encompass a subregex, results (submatches) land in @() or $0... (not limited to $9 anymore) — see also: [ ] «metachar»

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

*

* «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

* «numeric op» — infix multiplication, forces numeric context

* «signature symbol»prefix which indicates slurpy arrays in signatures

* «twigil»twigil of global variables that are accessible in all scopes

* «regex metachar» — quantifier for zero or more findings

** «numeric op» — raises a number to a power, forces numeric context — example: 2 ** 3 is 8 because its 2 * 2 * 2 — alias to exp

** «regex metachar» — not backtracking, greedy quantifier taking zero or more findings

**n «regex metachar» — quantifier for explicit repeat char or group, like x *(string op) does outside of a regex — example: (ha)**3 only matches 'hahaha'

**? «regex metachar» — quantifier for minimal matching, just as much to fulfill with the pattern — example: ``

+ «context op» «numeric op»infix addition operator, forces numeric context on both operands, so it does if its used only as prefix, opposite of -

+ «regex metachar» — quantifier for one or more findings

+& «numeric op» — bitwise AND, forces numeric context

++ «sequence traversal» — generic autoincrement, changes this value to its next neighbour in its ordered set, can be used as prefix (take effect before evaluating the surrounding term) or suffix (incrementing afterwards), alias to succ, opposite of --

+< «numeric op» — shift left in numeric context

+> «numeric op» — shift right in numeric context

+^ «numeric op»infix bitwise XOR, that looks at ot operands in numeric context

+| «numeric op»infix bitwise OR, forces numeric context

, «list op»infix generating operator — example: 1, 'two', 3.2 creates a list with three elements — see also: [ ]

-

- «numeric op»infix subtraction operator, forces numeric context on both operands and does so (and negates) if used only as prefix, opposite of +

-- «sequence traversal» — generic autodecrement, changes this value to its previous neighbour in its ordered set, can be used as prefix (take effect before evaluating the surrounding term) or suffix (incrementing afterwards), alias to pred, opposite of ++

--> «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)

. «twigil»twigil of public accessors (getter/setter methods)

. «regex metachar» — matches one character, any character (including a \n - unlike in Perl 5)

<.s> — prefix for a subrule that doesn't capture (matches will not be remembered)

.. «ranges», «list op»infix range generating operator, produces a Range object in item context which generate lists in list context

... «list op»infix sequence generating operator, can figure from example number out if a series is arithmetic (give 2) or geometric (give 3), can produce a sequence with a generator routine — example: @a = 1, 2, 4 ... infite lazy list of all powers of two, 1, 1, *+*, ... 1000 returns fibonacci numbers lower equal then 1000

... «yadda op»yadda operator that calls fail (exception), marks unimplemented empty routine bodies

/ «numeric op»infix division, forces numeric context — see also: div

/ «rat composer» — gives you a rational number that keeps track of its numerator and denominator when inside round brackets, example: (3/7)

/ «unspace op» — every following whitespace will be ignored

$/ «special var» — last created match object of this block with the following methods

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

\0s[n] «escape sequence» — character given in octal, decimal or hex (when s 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], Perl 5: $0 is $*EXECUTABLE_NAME

:s(s) — Pair generation operator, also known as adverbial syntax — example: $pair = :key('value')

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

: «io path method» — start of all test methods (r w x o R W X O e z s f d l L p S b c t u g k T B M A C) in the adverbial form — example: $filename.IO ~~ :X

: «twigil»twigil of autogenerated named parameters of a block

:s «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)

; «terminator» — separates statements (commands) or array indices — 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» — hyper metaopeartor, right side dicates the lengths of the result, has a unicode sibling — example: 2 <<+=<< @b increments numeric value of every array element by 2

<<== «sequencer op» — leftward pointing feed operator that adds values to an existing list (append-mode) — see also: <== and ==>>

<< >> «quoting op»circumfix quoting operator to autoquote of words and return them as a list, with quote protection and evaluation of variables, alias to: Q :qq :ww /.../ or « » (unicode sibling) — see also: < >

<= «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, infix less-equal-greater comparison for sortable classes, so called "spaceship operator", does a cmp of the into numeric context converted values of both sides, as leg does in string context — example: 3 <=> 4 returns -1, 3 <=> 3 returns 0, 4 <=> 3 returns 1

< > «quoting op»circumfix quoting operator that autoquotes words and returns them as a list, without quote protection and evaluation of variables like << >>, alias to qw/.../ or Q :q :ww /.../

var[ ]postcircumfix operator appended on a hash var(no more spaces in between allowed), returns a slice slice with values which keys was inside the brackets — example: %h = {a=>1, b=>2, c=>3}; say %h<c a> returns '3 1'

< > «regex metachar» — embraces an subrule (assertion), if it doesn't start wit a ., ? or ! findings will stored under the name of the subrule as named capures into $/<name> and $<name>

=

= «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

op= «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 two variables, if their bound to same memory location (in symbol table)

== «num comparison»True if values are equal in numeric context, as eq does in string context

=== «comparison op»infix check for 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 — see also: <== and ==>>

==>> «sequencer op» — rightward pointing feed operator that adds values to an existing list (append-mode) — see also: ==> and <<==

=> «op»Pair (and Hash) constructor called fat arrow — example: $pair = 'key' => 'value'; — alternative to the adverbial syntax

> «num comparison»infix op, numeric greater than

>= «num comparison» infix comparison op, numeric greater than or equal

>> «meta op» — hyper metaopeartor, left side dicates the lengths of the result, has a unicode sibling — example: @a >>++ increments numeric value of every array element

?

? «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

? «regex metachar» — a leading ? in a subrule indicates a positive zero-width assertion like *, opposite of !

<?> «predefined subrule» — matches nothing, returns always True, opposite of <!>

?& «bool op» — logical AND op, forces boolean context

?? !! «conditional»ternary or conditional operator, condition ?? term1 !! term2 ; is a shortcut for if (condition) { term1 } else { term2 }, returns the result of the extecuted term, in Perl 5: ? : — see also: ||, ff, fff

??? «yadda op»yadda operator that calls warn

?^ «bool op» — logical infix XOR, forces operands into boolean context

?| «bool op»infix logical OR, forces operands into boolean context

@ «sigil»sigil of an array

@() «context op» — forces (flattened) array context, alias to list() function

[l]circumfix operator that creates a scalar holding an array whose elements are the items inside the brackets — see also: ,

[p] «regex metachar» — encompass a subregex, results will not be remembered like with ( )

var[ ]postcircumfix operator appended on an array var(no more spaces in between allowed), returns an array slice with values which indexes was inside the brackets — example: @a = 1..5; say @a[2..4,1] returns '3 4 5 2'

[op] «meta op»circumfix reduction metaop, applies the operator between all elements of an array, alias to reduce

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

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

\c «escape char» — used inside quotes and regexes to build a control char or escape equence (regex only), also needed to escape special character there — see also: |

^

^ «junctive op»infix junctive XOR, requires that exactly one of operands is True in bool context to return 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 also: ~~

^ «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»infix logical (XOR) operator that operates with into bool context converted values of both operands without changing their content, in bool context it returns True or False as expected, in any other context it returns the first none empty value, the second when both are empty and Nil when both are not empty, precedence version of xor — example: ('dang' ^^ '') returns 'dang'

^^ «regex metachar» — start of a line

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

{} «terminator» — circumfix operator, encloses blocks if assigned it creates an anonymous routine, or a hashref when it is identified as a hash by the hash prefix or it 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)

<|c> «escape char» — used to escape or mark «zero-width boundaries» inside regexes, surrounded by angle brackets (< >), to distinkt it from the metachar above — see also: \

|() «context op» — flatten capture object into arglist, (named parameter)

|| «logical op»infix short circuit logical OR, evaluates sequentially left to right its operands until one is True in bool context, if there is one then the result is True in bool context, otherwise the first True value is returned or the last one, high precedence version of or — example: (3 || 5) returns 3 — see also: |, ?? !!

|| «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 on its operands (stringifies), if infix its concatenate strings - an 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»infix 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 into numeric context — example: abs -4.76 returns 4.76 as does abs 4.76 — see also: round, sign, truncate

after «generic comparison» — generic comparison operator used by the Order class, True if left should follow right

<!after p> «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

<?after p> «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: &

<alnum> «predefined subrule» — a single alphanumeric character, equivalent to <+alpha +digit>

<alpha> «predefined subrule» — a single alphabetic character

also — keyword to define inharitance from classes and roles inside an object, class or role — see also: is, does

and «logical op»infix short circuit logical AND, evaluates sequentially left to right its operands until one is False in boolean context, if one was False the result in boolean context is False, otherwise the last evaluated operand, low precedence version of && — example: 'hurray' and 0 returns 0 — see also: andthen, all

andthen «logical op» — logical AND short circuit operator, transferring $_ from first to second block or expression, if first did succeed — example: {...} andthen { .say } — see also: orelse and and

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 junctions)

any «junctive op»junctive OR operator, True when any one condition (of a following list) is true in boolean context — see also: |

$*ARGFILES «special var» — magic command-line input handle, in Perl 5: ARGV

@*ARGS «special var» — arguments (parameter) to a program (script), in Perl 5: @ARGV

args «callframe method»

arity «routine method» — returns how many parameters this routine requires, .count includes also the optional — see also the glossary term

Array «mutable type» — Perl array, container for a series of Scalar value container

: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

assertion «grammatical category» — namespace for regex assertions like !

assoc «routine trait» — specifies the associativity of an operator explicitly

assuming — method of all routine objects that enables currying

async «block modifier» — allows the interpreter to parallelize the following term

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 «io path method» — 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 <<...>>

backslash «grammatical category» — internal namespace for escape sequences like \w

: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

<!before p> «predefined subrule» — negative zero-width lookahead, if after this position follows the given pattern inside the angle brackets, the whole pattern will not match

<?before p> «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.)

<blank> «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

&?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

bounds «range method» — returns a list with same start and end point as the range (first parameter)

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

but — adds a role to a class

.bytes (Buf --> Int) «string method» — number of bytes (a sort of Perl 5's length) on buffer like types — example: $var.encode($enc).bytes — see also: chars, codes, graphs

:bytes «regex modifier» — instructs regex to search on byte level — see also: :chars, :codes, :graphs

C

:c «io path method» — 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

<|c> «escape sequence» — codepoint boundary, zero width space between two unicode codepoints, opposite is <!|c> — see also: <|g> and <|w>

cached «routine trait» — marks a routine as being memoized

call — execute a routine

caller — returns an object that describes the routine from which the current routine was called

callframe — returns a callframe object, that describes the current execution state, with the following methods

callsame — alias to: callwith( |callframe(Routine).args ) — see also: nextsame

callwith — method which can call a routine with a different signature — see also: nextwith

capitalize — alias to a wordwise ucfirst (exists only in Perl 5), makes first char of every word uppercase, rest lowercase

Capture «immutable type» — type holding arguments for a routine call (right-hand side of a binding)

cat «array op & 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 op & 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 (Num $x --> Int) «num op & method» — lowest integer not less than $x, rounding up to the next whole number — example: ceiling 5.4 returns 6, ceiling -5.4 returns -5 — see also: floor, round, truncate

chr (Int --> Str) «num method» — convert number into character according a character table (UTF), reverse of ord

chrs (Array of Int --> Str) «num method» — converts every number to a character with that index and combines them to one string, plural of chr, reverse of ords

chars (Str --> Int) «string method» — returns number of characters of a string, in Perl 5: length — see also: bytes, codes, graphs

: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 (like on Unix)

chomp (Str --> Str) «string method» — returns a copy of a string with the last newline (\n) (if there is one) removed — see also: chop, trim

chop (Str --> Str) «string method» — returns a copy of a string with the last character removed — see also: chomp, substr

chown — changes owner of files

chroot — change root directory on POSIX like systems

cis «Complex method» — see also: conj, polar, unpolar

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 «special var» — current class object

::?CLASS «special var» — name of the current class

class «block modifier» — declares the following block to be a class, (more) — see also method, submethod, has and role

classify «array op & 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 op & method» — releasing the connection to a file via a file handle

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

cmp «generic comparison» — general infix comparison operator, result is Increase (numerically -1) if before would return True (left side is ordered before right) - Same (numerically 0) if eqv - Decrease (numerically 1) if after — see also: leg and <=>) which do the same in string and numeric context

Cn

<cntrl> «predefined subrule» — a not visible character that is aimed to control the console output, the complete list

code «context op» — forces callable context, alias to &()

:code «quoting adverb» — enables quasiquoting, the commented will be compiled and the resulting AST is the return value — quasi {...} is an alternative to Q :code /.../

codes (Str --> Int) «string method» — number of unicode codepoints of a string in a language-independent way — see also: bytes, chars, graphs

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

@=COMMENT «special var» — contains all the comment blocks of that file

Complex «immutable type» — Perl object type to hold a complex number, consisting of a "real value" (Num) and an "imaginary value" (the thing with the i == sqrt(-1))

conj (Complex $c --> Complex) «complex method» — returns ($c.re - $c.im), the complex conjugate see also: cis, polar, unpolar

conj «complex method» — convert complex number into real (Num) (conjugate) — see also: abs, sign, truncate, unpolar, re, im

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(n) «regex modifier» — searching from nth position (counting from 0) and then going to the right, long alternative of :c

CONTROL «closure trait» — marks as a prefix a special block to catch control Exception (like raised with 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» — metaoperator that seeks every combination of one element of one list with an element of a second list and applies then an infix operator to that pair, returns a list the results, alias method to X metaoperator — example: @a X~ @b equals (@a; @b).crosswith(&[~]) equals (@a; @b).cross.lol.map { .reduce(&[~]) }

$*CWD «special var» — current working directory as Str

D

:d «io path method» — check if file is a directory

\D «escape sequence» — a single nondigit character

\d «escape sequence» — a single digit character, alias to <digit>

$=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 «conditional» — following block will be run if no when clause in surrounding given 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 ( --> Int) «rat method» — returns the denominator of a rational number (value type Rat and FatRat), opposite of numerator — see also: nude

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

<digit> «predefined subrule» — single (decimal) digit char, alias to \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 «int op»infix integer division — like any other division, just does a trunc on the result — example: 5 div 2 returns 2 — see also: /, mod

do — executes a block, the "do once" loop

does — defines that this class, role, or object inherits from this role (only parameter) — checkes if there are any conflicts with existing attributes or methods

dotty «grammatical category»

:double «quoting adverb» — enables double quoting, q with interpolation of variables, alias to "...", qq /.../ or Q :s :a :h :f :c :b /.../, long alternative of :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 «constant» — about 2.71828182878434, fundamental mathematical constant, important to the functions exp and log

:e «io path method» — tests if file exists

\E «escape sequence» — anything but an escape character

\e «escape sequence» — escape character

Each «undefined value type» — ordered superposition (conjectural), unlike Junction

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, opposite of lazy

$*EGID «special var» — effective global ID of the running process ($*PID) owner, in Perl 5: @) and $EGID

elems «array op & method» — number of elements (values) — see also: end

elems «hash op & method» — number of pairs

else «conditional» — introduces the alternative block after an if or elsif that is executed, when conditions of all alternatives resulted in False — see also: default

elsif «conditional» — alternative if clause

$?ENC «special var» — current encoding

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), in Perl 5: %ENV

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 — see also: looser and tighter

eqv «comparison op»infix operator, compares the dynamic state of objects and values, in contrast with static ===

$*ERR «special var»file handle for the standard error output (command line mostly), in Perl 5: STDERR

$*EUID «special var» — effective user ID of the running process ($*PID) owner, in Perl 5: @> and $EUID

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

evalfileeval 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 alternative 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 as command (as typed into a shell) and results returned, long alternative of :x, used by qx/.../ and qqx/.../

$*EXECUTABLE_NAME «special var» — name of the main scripts file name, in Perl 5: $0

:exhaustive «regex modifier» — searching at all positions as long as it findes something (with backtracking), long alternative for :ex

exists — checks for existence of a variable, array or hash element, also scalar method

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

exp (Num $base, Num $exp? --> Num) — exponentiate, alias method to: $base ** $exp (defaults to e)

export «routine trait» — this routine will be exported by the current module by default

F

:f «io path method» — 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» — any character but form feed

\f «escape sequence» — form feed character (\u000C), as in Perl 5

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

FALLBACK — method of each class that will be called, if a method call fails — similar to P5 AUTOLOAD

Failure «undefined value type» — data type object for an error, thrown by an unhandled Exception

Falseboolean value aka Bool::False, 0 in numeric context, '' (empty) in string context, opposite of True

FatRat «immutable type» — Perl rational (unlimited precision in numerator and denominator) — see also: Rat

fc (Str --> Str) «string method» — return a copy of a string where the Unicode "fold case" operation is done upon, suitable for doing caseless string comparisons — see also: lc and uc

ff «conditional» — 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 in Perl 5: .. in scalar context

fff «conditional» — flip flop operator in the style of sed, tests $_ against two values, after return value became True ($_ is larger then left value), right side will be tested during next loop iteration, can be combined with ^ to exclude borders in Perl 5: ... in scalar context

$?FILE «special var» — current filename of source file

file «callframe method»

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 $x --> Int) «num method» — highest integer not greater than $x, rounds down no the next whole number — example: floor 5.4 returns 5 floor -5.4 returns -6 — see also: ceiling, round, truncate

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 «loop» — loop that only iterates over the following list and sets $_ for each iteration (is a 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 numeric 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 «io path method» — 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, opposite is <!|g> — 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 «io method» — returns a line (in item context) or all lines (in list context) from file handle — see also: lines, words

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, in Perl 5: @( and $GID

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

given «conditional» — 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 alternative of :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 and roll

grabpair «hash method» — random selection n (only parameter) of hash pairs, (each pair only once) — see also pick and roll

grammar «block modifier» — special kind of class with methods like regex, token, rule that apply regexes as named subpattern. Produces a match object. The name is ment like in "Parsing Expression Grammar" (PEG)

$?GRAMMAR «special var»grammar of the currently used slang (mostly $~MAIN)

<graph> «predefined subrule» — a "graphical" character, calles grapheme

graphs (Str --> Int) «string mmethod» — number of unicode graphemes of a string, in a language-independent way — see also: bytes, chars, codes

:graphs «regex modifier» — searching on the level of language-independent graphemes — 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 in string context, 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 alternative of :hash, included in "...", qq/.../ and <<...>>

\H «escape sequence» — anything but horizontal whitespace char

\h «escape sequence» — a horizontal whitespace char, build together with vertical whitespace the sum of all whitespace character

handlesdelegates execution of a method to a method of an attribute

HardRoutine «immutable type» — a routine that is committed to not changing

has «scope declarator» — introduces attribute names — see alsoclass

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, can be also seen as a Set of Pairs

hash «context op» — enforces hash context, alias to %()

:hash «quoting adverb» — demands evaluation of hash variables that start with the % sigil, long alternative of :h, included in "...", qq/.../ and <<...>>

:heredoc «quoting adverb» — defines end marker for the following heredoc, long alternative of :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 «constant»square root of -1, fundamental mathematical constant to build Complex with, important to the functions

:i «regex modifier» — uppercase and lowercase variants of a letter are taken as the same letter, short alternative for :ignorecase (same as in Perl 5)

<ident> «predefined subrule» — an identifier

if «conditional» — 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 alternative for :i (as in Perl 5)

:ignoremark «regex modifier» — comparing base characters (unicode non-mark characters) while ignoring any trailing mark characters, long alternative for :m

:ii «regex modifier» — only for substitutions, replacing with chars that have the same case pattern as the replaced, short alternative for :samecase

im «complex method» — imaginary part of a complex number — see also: truncate, unpolar, re

import — just import definitions from an already loaded module — see also: use and need

$*IN «special var»file handle for the standard input (command line mostly), see also $*OUT, in Perl 5: STDIN

@*INC «special var» — include pathes (but not for standard library modules), in Perl 5: @INC

indent — method of any string object that prepends n (only parameter, can get negativ) space in any not empty line

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 *

infinite «list method» — answers if a range or list is infinite with True, False or Mu

infix «grammatical category» — namespace of symbols that stay between two statements, that become their parameters — example (plus): $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: (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 «callframe method»False if that block is called like a routine

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 — keyword for to express that one class inherits from another — bind a trait to a variable — see also: also

is-prime — method of any Int object returning a Bool

item() «context op» — forces scalar context, alias to $()

Iterator «mutable type» — Perl list

iterator «list method» — returns the iterator of a 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'does this too:(1..5).join("-")`

Junction «undefined value type»junction - unordered superposition of data ordered superposition (conjectural), unlike Each

K

:k «io path method» — 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 context

KeySet «mutable type» — KeyHash of Bool (does Set in list context

keys «array op & method» — returns the list of 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 «io path method» — Actual path is a symbolic link (readlink)

:l «io path method» — file is a symbolic link

\L[n] «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 (Str --> Str) «string method» — return a copy of a string where all characters are lowercase — see also: fc and uc

lcfirst «string op & method» — make first character of a string lowercase

lcm «numeric infix op» — least common multiple — example: 4 lcm 6 returns: 12 — see also: gcd

le «string comparison»infix operator, result is True if left side is lower than or equal than the right in string context — see also: lt, ge, leg

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»infix comparison operator that sees its operands in string context, but works otherwise like cmp (general form) or <=> (numerical context), leg stands for leg lower/equal/greater as in lt, eq,gt — in Perl 5: cmp — example: 'hammer' leg 'vanilla' returns Increase

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 — see also: words, get

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 (Num $x, Num $base?) — logarithm of $x to the $base (default is e, together also known as ln)

log10 — logarithm to the base of 10, also known as log on calculators and lg in math classes

LoL «immutable type» — arguments in a semicolon list, name is short for "List of Lists"

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 «loop» — 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 one rank lower than an existing operator

<lower> «predefined subrule» — a single lowercase character

lt «string comparison»infix operator, lower than, True if alphabetically ordered the left comes before the right — see also: gt, le, leg and <

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»compile-time subroutine, that can alter the program itself

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

make

map «array op & method» — take a list, perform a block on each member, return a list of the results in same order, the current value is each time in $_ of use autonamed positionals — example: map { chr $_ }, 66..69 or map { chr $^nr }, 66..69 results in <B C D E>

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/.../ operator, $str.match(/p/) equals $str ~~ m/p/;, returns a match object that end up also in $/ — see also comb

max «array op & method» — returns the numerically largest value from a given list — see also: min and minmax

maybe «block modifier»

metachar «grammatical category» — internal namespace for regex metacharacters like .

Method «mutable type» — type of Perl method objects

method «routine type» — defines a method (inheritable routine) in a class

min «array op & method» — returns the numerically smallest value from a given list — see also: max and minmax

minmax «array op & method» — returns the numerically highest and lowest values from a list as a 2 item list — minmax 2,4,1,7,3,5 returns 1,7 — see also: min and max

mkdir — creates a directory with given name

:mm «regex modifier» — substitute with chars that has same mark/accent pattern as the matched string, short alternative for :samemark

mod «numeric op»«numeric op»infix modulo operator, remainder of a int division, forces numeric context, low precedence version of % — example: 5 mod 4 returns 1

mod_internal «grammatical category» — internal namespace for regex modifier like :P5

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 value

multi «routine modifier» — marks routines that can have sibling with same name but different signature, when name is called, the one with matching signature is run (multimethod dispatch) — example: multi sub name (...) {...} — opposite of: only

my «scope declarator» — introduces lexically scoped names, which exists only in the current scope and cease to exist, once this scope is executed

N

\N «escape sequence» — anything but a (logical) newline

\n «escape sequence» — logical (platform independent) newline, not just a LINE FEED (LF) character (u000A)

n:nd «regex modifier» — demands the nth finding (:2nd), has many aliases (:st, :rd, :th) for correct spelling (:3rd)

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 also: 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

«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 — alias to: nextwith( |callframe(Routine).args ) — see also: callsame

nextwith — method which can call a routine with a different signature — see also: callwith

$?NF «special var» — method name (options: <NFC NFKC NFD NFKD>) how strings are going to be normalized, codes and bytes have an optional pramameter which method should be used, that defaults to $?NF

Nil «undefined value type» — unlike undef in Perl 5 it really means no value here — example: @a = Nil, Nil; result array has zero elements

none «junctive op»NOT operator, returns True when a value is not part of a Set, junctive

normalize (Str --> Str) «string method» — normalize (repair) unicode string

not «context op»prefix logical NOT operator, converts to boolean context and then inverts the value, low precedence version of !(), opposite of so

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

nude ( --> Seq[Int]) «rat method» — returns a list of numerator and denominator — see also: numerator and denominator

Num «immutable type» — Perl number (approximate "real", generally via floating point) — see also: Rat and Int

numerator ( --> Int) «rat method» — returns the numerator of a rational number (value type Rat and FatRat), opposite of denominator — see also: nude

O

:O «io path method» — tests if file is owned by real uid ($*UID)

:o «io path method» — tests if file is owned by effective uid ($*EUID)

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: | op

only routine modifier — permits only one routine of the same name in this block (no MMD) — example: only sub name (...) {...} — opposite of: multi

open «path method» — establishes a connection to a file via a file handle

$*OPTS «special var» — options from command line

or «logical op» || «logical op»infix, short circuit, logical, OR, evaluates sequentially left to right its operands until one is True in bool context, if there is one then the result is True in bool context, otherwise the first True value is returned or the last one, low precedence version of || — example: ?('hurray' or 5) returns True — see also: any, orelse, xor

ord (Str --> Int) «string method» — converts a character into number according a character table (unicode), reverse of chr

ords (Str --> Array of Int) «string method» — get the index numbers of some characters, plural of ord, reverse of chrs

orelse «logical op» — logical OR short circuit operator, transferring an error code from first to second block/command, if first do not succeed (returns Nil) — low precedence version of // — example: {...} orelse { note $! } — see also: andthen

our «scope declarator» — introduces package scoped names for variables and routines

$*OUT «special var»file handle for standard output (command line mostly) — see also: $*IN, in Perl 5: STDOUT

: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 «io path method» — file is a named pipe (FIFO) or file handle is a pipe

:p «quoting adverb» — quote paths and create path object that know the right format of the current $*KERNEL — example: Q :p /.../ — short for :path or use qp directly

:p «var adverb» — get array or hash slices in hash context — example: my @a = 1..4; say @a[2] output: "2 => 3" —

:p(n) «regex modifier» — searching only on the nth (n is an int) position (counting from 0), short alternative of :pos

:P5 «regex modifier» — activate old Perl 5 regex rules, hort alternative of :Perl5

$~P5Regex «special var» — current grammar of the Perl 5 compatible regular expression slang

pack format values into or from a condensed format, which is specified by keys or an own template

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, created with a fat arrow or the adverbial notation

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

Parcel «immutable type»arguments in a comma list

parcel «parameter trait» — raw reference, will not be contextualized

parse «grammar method» — commands a grammar to parse a string (fist parameter), resulting in a match object, but only if the whole string matches — see also: subparse

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 — example: Q :path /.../ — long alternative for :p or use qp directly

perl ( --> Str) «formater» — transforms data structure (object) into syntax of Perl 6 source code, in most cases eval turn it back into the data structure, use instead of Perl 5: Data::Dumper — see also: gist

$*PERL «special var» — Perl version running under, in Perl 5: $] and $^V

$?PERL «special var» — Perl version this program is compiled for

:Perl5 «regex modifier» — activate old Perl 5 regex rules, long alias to :P5

pi «constant» — about 3.14159265394248, also known as π, fundamental mathematical constant, ratio of a circle's circumference to its diameter

pick «array op & method» — select a number (optional first parameter) of random vaues (without duplication), take roll to enable duplication — see also: rand

$*PID «special var» — ID of the running process, in Perl 5: $$ and $PID

Pn

$=pod «special var» — object that contains all surrounding POD documentation

polar «Complex method» — magnitude or angle corresponding to the complex number (only parameter), the magnitude is non-negative, and the angle in the range -π ..^ π — see also: cis, conj, unpolar

pop «array op & method» — removes and returns the last element in an array

:pos(n) «regex modifier» — searching only on the nth position (counting from 0), long alternative 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 — example (++): $a++

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

PRE «closure trait» — marks as a prefix a special block, assert precondition, executed at every block entry, before ENTER

pred (Num $f) «sequence traversion» — returns the predecessor of $f, alias to -- operator, opposite of 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 (<<): ++<< @a

print — sends a string to an output stream (default is ($*OUT, but can also be any file handle ) without adding a newline like say

<print> «predefined subrule» — a single printable character

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

<prior> — standard grammar's rule for whatever the prior successful regex matched

proceed «flow control» — leave this when block but keep on validating the next when clause — see also: succeed and leave

promptprint - 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

<punct> «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, provides just mechanism to encompass a string and return content, understands a list of adverbial modifier

q «quoting op» — does single quoting (eval only \\ and \'), alias to '...'** and Q :q /.../ and Q :single /.../ — see also: qx

:q «quoting adverb» — simple quoting (slashes and '), alias to '...' and q /.../, short alternative for :single

\Q[n] «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 :qq /.../ and Q :double /.../ and Q :s :a :h :f :c :b /.../,

:qq «quoting adverb» — activates double quoting, q with interpolation of variables and blocks, Q :qq is alias to "...", qq/.../ and Q :s :a :h :f :c :b /.../, short alternative for :double

qqx «quoting op» — run a double quoted string as system call (as typed into a shell) and return results, in Perl 5: qx/.../ or `...` — alias to: Q :x :qq /.../ — see also: qx and qq

quantifier «grammatical category» — internal namespace for regex quantifier like *

$~Quasi «special var» — current grammar of the quasiquoting language

quasi «block modifier» — declares following block as quasiquotes code, it will be compiled and the AST will be returned — 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

quotemeta «string method» — returns the input string with all non-"word" characters (\W) back-slashed

:quotewords «quoting adverb» — split quoted string into words (on whitespaces) but with quote protection, long form of :ww, used in <<...>>

qw «quoting op»circumfix quoting operator that autoquotes words and returns them as a list (as in Perl 5), without quote protection and evaluation of variables like << >>, alias to < > or Q :q :ww /.../

qx «quoting op» — run a single quoted string as system call (as typed into a shell) and return results, alias to: Q :x /.../ — see also: qqx and q

R

:R «io path method» — check if file is readable by real uid ($*UID) / gid ($*EUID)

:r «io path method» — check if file is readable by effective uid ($*EUID) / gid ($*EUID)

\R «escape sequence» — anything but return

\r «escape sequence» — carriage return (CR - \u000D), as in Perl 5

Rop «meta op» — reverse operands — example: 4 R- 3 result: -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 2 values and the range operator in between 1 .. 10, caret (^) exludes a limit 1 ..^ 10 or can be used as upto-operator

RangeIter «mutable type» — iterator over a Range

Rat «immutable type» — Perl rational number (exact real numerator, limited denominator) — see also: FatRat and Num

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

re «complex method» — real part of a complex number — see also: im, unpolar, truncate

read «Buf method» — read n (first parameter) bytes from a buffer

readline — reads until the next \n from a Buf or Str

readonly «parameter trait» — immutable parameter

redo «flow control» — re-starts processing of the current loop turn

reduce «list method» — alias to [ ] «metaoperator» that applies an infix operator between each adjacent elements of a list and evaluates this term to a single value — example: [+] @a is equivalent to @a.reduce(&[+]) numerical sum of all elements

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 also: rule, token

:regex «quoting adverb» — parse as quoted string as regex

reify «range method» — forces the iterator of a list to create the next n (first parameter) elements — see also: reify — example: (1..5).reify(2) result: 1, 2, 3..5

$~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 «loop» — 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» — forces execution to leave this routine and sets the return value — see also: leave

returns «routine trait» — describing the type of value is produced (returned)

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

Rn

role «block modifier» — 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 n (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 — see also exp and log

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;@a = 1..5; say @a.rotate(-2) outputs 4 5 1 2 3

round (Num $f --> Int) «num method» — returns the nearest whole number — example: round 5.5 returns 6, round -5.5 returns -5 — see also: abs, ceiling, floor, truncate

roundrobin «array method» — kind of zip that ignores empty lists — example: roundrobin([1..3],[1,2],[1]) returns 1,1,1,2,2,3

&?ROUTINE «special var» — current routine object

routine_declarator «grammatical category» — internal namespace for routine declarators

rule «routine type» — in a grammar its the alias for regex :ratchet :sigspace — see also: 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 routine as returning an lvalue

rw «parameter trait» — mutable parameter (rw stands for: read write), can be changed by the routine given to

: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/ / / «regex quoting op» — perform a substitution based on rx-matches in place, creates anonymous regex, alias to Q :subst /.../.../ and .subst() — see also ss/.../.../ and m/.../

Sop «meta op» — force sequential (synchronous) evaluation, suppresses any explicit or implicit parallelism

:S «io path method» — file is a socket

:s «io path method» — 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, ms/.../ is alias to m:s/.../, short alternative for :sigspace

\S «escape sequence» — anything but whitespace

\s «escape sequence» — any whitespace character, horizontal (\h) and vertical (\v** )

<?same> «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 alias of :ss — example: ss/teh hsa/the has/; — see also: :sigspace

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

say«handle method» — writes a stream into a file and appends a \n

Scalar «mutable type» — object to hold a Perl scalar, a variable for a single value of any type

: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> in case you want to create your own

seed — initialize a random number generator, optionally with a value

self «term» — alias to object that the method was called on, available just inside a method

Set «immutable type» — unordered collection of values that allows no duplicates

set «array op & method» — creates a Set — example:

sigil «grammatical category» — word to name the namespace for sigils, used to redifine them or define your own with a macro

sign ($f) — 1 if $f is greater than 0, -1 if < 0, 0 when equal 0, undefined when undefined — see also: abs, round

Signature «immutable type» — object type to hold all information a signature like parameter types and values, return type, etc.

signature «routine trait» — declares a signature of a routine, normally declared implicitly, by providing a parameter list and/or return type between name and the corresponding block

:sigspace «regex modifier» — whitespace separates now subregex and don't stand for spaces to look for, ms/.../ is short alias to m:sigspace/.../ or m:s/.../ long alternative for :s,

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 form of :q

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

slurp --> Str | Buf «path and file handle method» — reads an entire file into a variable with or without a file handle — see also: spurt

Sn

so «context op» — converts value into the boolean context, low precedence alternative to ?, opposite of not

SoftRoutine «mutable type»routine that is committed to staying mutable (changable)

sort «list method» — returns the list in a sorted order by measures provided by the first parameter, this can either be a block like in sort {$^a leg $^b}, @input (see ^) or shorter with sort &[leg], @input (see leg) or yet even shorter by sort ~*, @input (see ~) for sorting in string context

<space> «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 — splits a string according a delimiter (string or regex) into an array of substrings — example: split(rx/-/, "1-2-4-5") returns 1,2,3,4 — see also: comb

sprintf «formater» — inserts formated values out of variables into a string like printf, but returns the string instead of outputting it

spurt «path and file handle method» — writes into a file (first parameter) data (second) with or without a file handle — see also: slurp

sqrt (Num $f) — square root of $f — see also: exp

ss/ / / «regex quoting op» — performs rx based substitution, spaces are just subrule separators, ss/.../.../ is alias to s:ss/.../.../ — example: ss/teh hsa/the has/;

:ss «regex modifier» — only for for substitution, whitespace separates subregexes like :sigspace, but also in the second part, substitution wil work then word for word, short alternative of :samespace

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

Stash «mutable type» — a symbol table hash (package, module, class, lexpad, etc)

stat «io path method» — available information about a file or link (call stat :link instead of Perl 5: 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 (if): $a++ if $a > 3

statement_mod_loop «grammatical category» — internal namespace for special group of block modifier that turn the block into a loop

statement_prefix «grammatical category» — internal namespace for block modifier — example: do

Str «immutable type» — Perl string - a finite sequence of unicode characters

Sub «mutable type» — Perl subroutine object

sub «routine type» — defines a routine, a block callable by name — example: name();

Submethod «mutable type»method than can't be inherited by other classes, only called by objects of the class, where it is defined

submethod «routine type» — defines methods, not inherited by subclasses like a method

subparse «grammar method» — commands a grammar to parse a string (fist parameter). Resulting in a match object, even if just part of the string matches — see also: parse

subset — define a subtype — example: 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 (Str $string, Int $start, Int $length? --> Str) «string method» — return a substring of $string from $start position and maybe with $length, works like in Perl 5 except fourth parameter was cut — example: substr('Hackathon', 1, 3) returns 'ack' — see also: chop

succ (Num $f) «sequence traversion» — returns the successor of $f, alias to ++ operator, opposite of pred

succeed «flow control» — leave this when block and the surrounding given block too — see also: proceed and leave

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

T

:t «io path method»file handle is opened to a "tty" (terminal)

\T «escape sequence» — anything but a tab

\t «escape sequence» — tab \u0009, not visible character (control char)

$?TABSTOP «special var»

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

tc (Str --> Str) «string method» — return a copy of a string where first character is uppercase, rest unchanged usable as operator and as method — see also: fc and lc

tclc (Str --> Str) «string method» — return a copy of a string where first character is uppercase, rest changed to lowercase usable as operator and as method — see also: fc and lc

temp — , in Perl 5: local

term «grammatical category» — namespace of terms, used to redifine them or make a new with a macro — example: *

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

titlecase (Str --> Str) «string method» — performs a Unicode titlecase operation on the first character of each word of the string

: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» — example: is

trait_verb «grammatical category» — example : of

trans «string method» — transliteration, replacing several specific character of a string with other chars, much more effective than with several s/.../.../ method alias for tr/.../.../ operator, $str.trans( %mapping ) equals $str ~~ tr/%mapping.sort.keys/%mapping.sort.values/;

:trans «quoting adverb»evals the quoted as transliterationQ :trans /.../.../ is alias to tr /.../.../ and .trans("..." => "...")

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

triangle «list method» — method alias to [\ ] metaoperator, [\+] @a equals @a.triangle(&[+])

trim «string method» — returns a copy of the string, with leading and trailing whitespace (\s) removed — see also: chomp

trim-leading «string method» — returns a copy of the string, with leading whitespace (\s) removed — see also: chomp

trim-trailing «string method» — returns a copy of the string, with trailing whitespace (\s) removed — see also: chomp

Trueboolean value aka Bool::True, 1 in numeric context, opposite of False

truncate (Num $f --> Int) «num method» — truncates the fractional part of a number — examples: truncate 4.27 returns 4, truncate -5.5 returns -5 — see also: abs, conj, round, sign

trusts — allows other (trusted) classes (first parameter) to access private attributes of that class

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 «io path method» — report if file has setuid bit set

\U[n] «escape sequence» — everything within the brackets is uppercase

uc (Str --> Str) «string method» — return a copy of a string where all characters are uppercase, usable as operator and as method — see also: fc and lc

$*UID «special var» — real user ID of the running process ($*PID) owner (user), in Perl 5: @< and $UID

UNDO «closure trait» — marks as a prefix a special block, executed at every unsuccessful block exit, part of LEAVE queue

uniq «list method» — returns only unique elements of a list (no value twice)

unless «conditional» — 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, alias to if not, no elsif or else is allowed to follow

unpolar «Complex method» — see also: cis, conj, polar

until «loop» — 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, alias to while not

unwrap — remove an enclosing routine, opposite of wrap

<upper> «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 (vars and routines), see also need and import)

V

\V «escape sequence» — anything but vertical whitespace (\v)

\v «escape sequence» — a vertical unicode whitespace character (LF | CR | FF | Line Tab | Next Line | Line Separator | Paragraph Separator), in numbers: u000A | \u000B | \u000C | \u000D | \u0085 | \u2028 | \u2029 | \u000D\u000A, together with vertical whitespace this sums up all whitespace character

value «pair method» — gets value (second) value of a pair (opposite of key) — example: (key => 'val').value; returns 'val'

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 «io path method» — check if file is writeable by real uid ($*UID) / gid ($*GID)

:w «io path method» — check if file is writeable by effective uid ($*EUID) / gid ($*EGID)

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

\w «escape sequence» — a word character (unicode alphanumeric - A..Z, a..z,0..9, "_")

<|w> «escape sequence» — word boundary, zero width space between two \w, alias to <wb>, opposite is <!|w> — 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) like note, but works more like print, without appending a \n

<wb> «predefined subrule» — zero-width word boundary between an \w and a \W character, alias to <|w> — see also <ww>

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 «conditional» — when following expression matches against $_ (set by given or for) it runs the code block after it — 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 «loop» — 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» — name of the package that support that object, long name in string context

WHY «introspection method» — documentation of that object— see also: #=

will do «routine trait» — block of code executed when the routine is called, normally declared implicitly, by providing a block after the subroutine's signature definition

words «string method» — splits a string into a list of words — example: $input.words($limit) equals $input.comb( / \S+ /, $limit ) — see also lines

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

wrap — creates enveloping routine that is called instead of the original, but can forward to it, opposite of unwrap

write «Buf method» — writes content of all parameter into that buffer

<ws> «predefined subrule» — whitespace between words aka \s*

:ww «quoting adverb» — split quoted string into words (on whitespaces) but with quote protection, short form of :quotewords, used in <<...>>

<ww> «predefined subrule» — zero-width space inside of a word between two \w character, see also <wb>

X

X «list op» — cross product of two lists, alias of cross method — example: 1,2 X 3,4 retuns 1,3,1,4,2,3,2,4;

x «string op» — string replicate operator to single string — example: 'ab' x 3 returns 'ababab';

Xop «meta op» — cross product with hyper operator, alias of crosswith method — example: <a b> X~ <y z> == <ay az by bz>;

:X «io path method» — check if file is executable by real uid ($*UID) / gid ($*GID)

:x «io path method» — check if file is executable by effective uid ($*EUID) / gid ($*EGID)

:x «quoting adverb» — quoted string will be executed as command (as typed into a shell) and results returned, short alternative of :exec, used by qx/.../ and qqx/.../

:x (n) «regex modifier» — searching n times 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)

<xdigit> «predefined subrule» — single hexadecimal digit char

xor «logical op»infix logical (XOR) operator that operates with into bool context converted values of both operands without changing their content, in bool context it returns True or False as expected, in any other context it returns the first none empty value, the second when both are empty and Nil when both are not empty, low precedence version of ^^ — example: (5 xor 0) returns 5 — see also: or, orelse

xx «list op» — replicate a list l (left operand) n times (right operand) — example: 'ab' xx 3 returns <ab ab ab>

Y

Z

Z «list op» — joines infix 2 lists and stops when one list runs out of elements, returning always an list with an even length, alias to zip — example: 1,2,3,4 Z 8,9 == 1,8,2,9 — see also: roundrobin

Zop «meta op» — joines infix the values from same position of 2 lists with following operator and produces in that manner a new list

zip «array op & method»infix zip operator, joines 2 lists, alias to Z «list op» — example: @a Z @b = (@a; @b).zip

zipwith «meta op» — alias method to Z «metaop» — example: @a Z~ @b aka (@a; @b).zipwith(&[~]) aka (@a; @b).zip.lol.map { .reduce(&[~]) }


Intro    Chapter:   0. History   1. Design   2. Basic   3. Var   4. Op   5. IO   6. Block   7. Sub   8. OOP   9. Regex   10. Meta
Overview   Appendix:   A. Index   B. Grouped   C. Classtree   D. Delta   E. Exciting   F. FAQ   G. Glossary   H. Href