appendix-a-index.txt

% Perl 6 Tablets Appendix A - Index

This index contains an alphabetic sorted list (as decided by [**leg**](#leg-op))
of all operators, methods, builtins, options, modifier and special variables
with short explanations, cross references, code examples and Perl 5 equivalents.
It is sorted without prefixes like colon, dot, backslash,
[*sigil*](appendix-g-glossary.html#sigil) or [*twigil*](appendix-g-glossary.html#twigil)
and everything that contains punctuation comes first.
Sometimes are added green placeholder:
<span class="you-provide">n</span> stands for a [integer number](#Int-type),
<span class="you-provide">f</span> is a floating [point number](#Num-type),
<span class="you-provide">s</span> [string](#Str-type),
<span class="you-provide">var</span> any variable,
<span class="you-provide">p</span> a *[regex pattern](appendix-g-glossary.html#regex)*,
<span class="you-provide">l</span> a list,
<span class="you-provide">op</span> any operator and
<span class="you-provide">t</span> any *[term](appendix-g-glossary.html#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 term is followed by a link «in french brackets» to a condensed summary
listing of its category in [appendix B](appendix-b-grouped.html)
or to the according category in the tablets.


<a id="nav-top"/>
**Navigation:
[`! "`](#exclamation) [`# $`](#pound)  [`% &`](#percent)  [`' (`](#single-quotes)
[`* +`](#plus)        [`, -`](#comma)  [`. /`](#dot)      [`0 :`](#colon)
[`; <`](#semicolon)   [`= >`](#equal)  [`? @`](#question) [`[ \`](#at)
[`^ _`](#caret)       [`{ |`](#curly-brackets)            [`~`](#tilde)**

**[A](#a)  [B](#b)  [C](#c)  [Cn](#cn) [D](#d)  [E](#e)   [F](#f)
  [G](#g)  [H](#h)  [I](#i)  [J](#j)   [K](#k)  [L](#l)   [M](#m)
  [N](#n)  [O](#o)  [P](#p)  [Pn](#pn) [Q](#q)  [R](#r)   [Rn](#rn)
  [S](#s)  [Sn](#sn)[T](#t)  [U](#u)   [V](#v)  [W](#w)   [X](#x)  [Y](#y) [Z](#z)**



Punctuation
===========

<a id="exclamation"/><a id="exclamation-op"/>
<a id="exclamation-context"/><a id="negation-op"/>
**\!** 
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
*[prefix](#prefix-category)* logical negation ([*NOT*](appendix-g-glossary.html#not)),
forces [boolean context](appendix-g-glossary.html#bool-context),
high precedence version of [**not**](#not)

<a id="exclamation-twigil"/>
**\!**
*[«twigil»](appendix-b-grouped.html#twigils)* &mdash;
[twigil](appendix-g-glossary.html#twigil) of private class and object variables

<a id="exclamation-signature"/>
**\!**
*[«signature symbol»](appendix-b-grouped.html#signature-symbols)* &mdash;
suffix for a required parameter in signatures, thats default if it's a named
parameter, not is it's a positional

<a id="exclamation-metaop"/>
**\!**<span class="you-provide">op</span> 
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
negates (mostly [comparison operators](tablet-4-operators.html#comparison))

<a id="exclamation-var"/>
**\$\!**
*[«special var»](appendix-b-grouped.html#special-variables)* &mdash;
last error message

<a id="exclamation-assertion"/>
**!**
*[«regex metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
a leading **!** in a subrule a negative zero-width assertion like
[**<!after ...>*](#after-negative-subrule), opposite of [**?**](#question-assertion)

<a id="exclamation-subrule"/>
**\<\!\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
opposite of [**\<?\>**](#question-subrule), returns always **[False](#False)**

<a id="exclamation-exclamation"/>
**!!** *[«conditional op»](appendix-b-grouped.html#conditionals)* &mdash; 
just second part of the ternary (conditional) operator after
**[??](#ternary-op)**, no op on its own

<a id="exclamation-exclamation-exclamation"/><a id="exclamation-yadda"/>
**!!!** *[«yadda op»](tablet-4-operators.html#yadda)* &mdash;
[yadda operator](appendix-g-glossary.html#yadda-operator)
that calls **[die](#die)**

<a id="double-quotes"/><a id="quotation-quotation"/>
**[" "](tablet-2-basic-syntax.html#double-quotes)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
double quoting, interpolates with
[**:s**](#s-adverb),    [**:a**](#a-adverb),   [**:h**](#h-adverb),
[**:f**](#f-adverb),    [**:c**](#c-adverb),   [**:b**](#b-adverb)
(all vars, functions, blocks, control chars),
alias to [**qq/.../**](#qq-op) or **Q** [**:qq**](#qq-adverb) **/.../**

<a id="pound"/><a id="comment-op"/>
**[\#](tablet-2-basic-syntax.html#single-line)** &mdash;
starts a comment that continues to the end of the line,
works even inside regexes as a
*[regex metachar](appendix-b-grouped.html#regex-metacharacter)*

<a id="pound-equal"/>
**[\#=](tablet-2-basic-syntax.html#pod)** &mdash;
starts comments to the lineending like **\#**, just makes
documenting comments that end up in
*[&routine.WHY.content](#WHY-introspection)* on the
following *[routine](appendix-g-glossary.html#routine)*

<a id="pound-apostrophe"/>
**[\#\`( )](tablet-2-basic-syntax.html#multi-line)** &mdash;
starts a multi-line comment that continues to the closing
bracket, works with any combination of bracket pairs

<a id="dollar"/> <a id="dollar-sigil"/>
**[\$](tablet-3-variables.html#scalar)**
*[«sigil»](appendix-b-grouped.html#sigils)* &mdash;
[prefix](#prefix-category) of [scalar
variables](tablet-3-variables#scalar)

<a id="dollar-op"/>
**$**()
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
forces [scalar context](appendix-g-glossary.html#scalar-context),
alias to the **[item()](#item)** function

<a id="dollar-metachar"/>
**$**
*[«regex metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
end of the string

<a id="dollar-dollar-metachar"/>
**$$**
*[«regex metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
matches the end of a line (no more multile mode)



# [%](#nav-top)

<a id="percent-sigil"/>
**%**
*[«sigil»](appendix-b-grouped.html#sigils)* &mdash;
[prefix](#prefix-category) of [hash variables](tablet-3-variables#hash)

<a id="percent-op"/>
**%**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
gives remainder of a modulo division,
forces [numeric context](appendix-g-glossary.html#numeric-context)

<a id="percent-context-op"/>
**%**()
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
forces [hash context](appendix-g-glossary.html#hash-context),
alias to the **[hash()](#hash)** function

<a id="percent-metachar"/>
**%**<span class="you-provide">s</span>
*[«regex metachar»](appendix-b-grouped.html#quantifier)* &mdash;
quantifier that repeat char or group as long as separated by
right expression &mdash; example: `\d % ','` matches `1,2,3,4,5` &mdash;
see also: **[%%](#percent-percent-metachar)**

<a id="percent-percent-op"/>
**%%**
*[«numeric op»](tablet-4-operators.html#numeric-context)*  &mdash;
**[True](#True)** if the left value is evenly
divisible by the right value

<a id="percent-percent-metachar"/>
**%%**<span class="you-provide">s</span>
*[«regex metachar»](appendix-b-grouped.html#quantifier)* &mdash;
quantifier that repeat char or group as long as separated by
right expression (like %), but allows trailing separator &mdash;
example: `\d %% ','` matches `1,2,3,4,5,`

<a id="ampersand"/><a id="ampersand-sigil"/>
**[&](tablet-3-variables#callable)**
*[«sigil»](appendix-b-grouped.html#sigils)* &mdash;
*[sigil](appendix-g-glossary.html#sigil)* of
[callables](tablet-3-variables#callable)
like [subs](#sub), [methods](#method)
and other [blocks](appendix-g-glossary.html#block)

<a id="ampersand-context"/>
**&**()
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
forces [callable](tablet-3-variables#callable)
context, alias to **[code()](#code-context)**

<a id="ampersand-op"/><a id="junctive-and"/>
**&**
*[«junctive op»](tablet-4-operators.html#junctions)* &mdash;
*[junctive](appendix-g-glossary.html#junction)* *[AND](appendix-g-glossary.html#and)*,
requires that all conditions are met, see also: **[all](#all)**

<a id="ampersand-metachar"/>
**&**
*[«regex metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
match multiple patterns (*[AND](appendix-g-glossary.html#and)*-connection of patterns)

<a id="ampersand-ampersand-op"/><a id="logical-and"/>
**&&**
*[«logical op»](tablet-4-operators.html#logical-selection)* &mdash;
*[infix](#infix-category)* short circuit logical *[AND](appendix-g-glossary.html#and)*,
[evaluates](appendix-g-glossary.html#evaluation) sequentially left to right
its operands until one is [**False**](#False) in
[*boolean context*](appendix-g-glossary.html#boolean-context), if one was **False** 
the result in [boolean context](appendix-g-glossary.html#bool-context) is **False**,
otherwise the last evaluated operand,
low precedence alias is [**and**](#logical-and) &mdash;
example: `0 and 7` returns `0` &mdash;
see also: **[&](#junctive-and)**

<a id="single-quotes"/>
**[' '](tablet-2-basic-syntax.html#single-quotes)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
simple quoting, just / and ' must be escaped, alias to
**[q/.../](#q-op)** or **Q :q/.../**

<a id="round-brackets"/>
**( )** &mdash;
grouping of values (parameters) to a **[Parcel](#Parcel-type)**

<a id="round-brackets-metachar"/>
**( )**
*[«regex metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
encompass a *subregex*, results (*submatches*) land in 
[**@()**](#round-brackets-var) or [**\$0**](#0-var)... (not limited to $9 anymore) &mdash;
see also: [\[ \]](#square-brackets-metachar)

<a id="round-brackets-var"/>
**@( )**
*[«special var»](appendix-b-grouped.html#match-variables)* &mdash;
holds positional submatches, **`$()[n]`** is alias to
[**`$/[n]`**](#slash-var) and [**`$n`**](#0-var)

<a id="asterisk"/><a id="asterisk-term"/>
**\***
*«term»* &mdash;
synonym for **[Whatever](#Whatever)**, for example, means **[Inf](#Inf)**
in a [range operator](#range-op) (**..**), means the
end of an array in a slice operator so that negative indices access
array elements relative to one beyond the final element

<a id="asterisk-op"/>
**\***
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
infix multiplication,
forces [numeric context](appendix-g-glossary.html#numeric-context)

<a id="asterisk-signature"/>
**\***
*[«signature symbol»](appendix-b-grouped.html#signature-symbols)* &mdash;
[prefix](#prefix-category) which indicates
[*slurpy arrays*](#slurpy-array) in signatures

<a id="asterisk-twigil"/>
**\***
*[«twigil»](appendix-b-grouped.html#twigils)* &mdash;
*[twigil](appendix-g-glossary.html#twigil)* of global variables that
are accessible in all *[scopes](appendix-g-glossary.html#scope)*

<a id="asterisk-metachar"/>
**\***
*[«regex metachar»](appendix-b-grouped.html#quantifier)* &mdash;
quantifier for zero or more findings

<a id="asterisk-asterisk-op"/><a id="power-op"/>
**\*\***
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
raises a number to a power,
forces [numeric context](appendix-g-glossary.html#numeric-context) &mdash;
example: `2 ** 3` is 8 because its `2 * 2 * 2` &mdash;
alias to **[exp](#exp)**

<a id="asterisk-asterisk-metachar"/>
**\*\***
*[«regex metachar»](appendix-b-grouped.html#quantifier)* &mdash;
not backtracking, greedy quantifier taking zero or more findings

<a id="asterisk-asterisk-number-metachar"/>
**\*\***<span class="you-provide">n</span>
*[«regex metachar»](appendix-b-grouped.html#quantifier)* &mdash;
quantifier for explicit repeat char or group, like
**[x](#x-op)** *(string op)* does outside of a regex &mdash;
example: `(ha)**3` only matches `'hahaha'`

<a id="asterisk-asterisk-question-metachar"/>
**\*\*?**
*[«regex metachar»](appendix-b-grouped.html#quantifier)* &mdash;
quantifier for minimal matching, just as much to fulfill with the pattern &mdash;
example: ``



# [+](#nav-top)

<a id="plus"/><a id="plus-op"/><a id="plus-context"/>
**+**
*[«context op»](appendix-b-grouped.html#contextualizers)*
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
[infix](#infix-category) addition operator,
forces [numeric context](appendix-g-glossary.html#numeric-context)
on both operands, so it does if its used only as [*prefix*](#prefix-category),
opposite of [**-**](#minus-op)

<a id="plus-metachar"/>
**+**
*[«regex metachar»](appendix-b-grouped.html#quantifier)* &mdash;
quantifier for one or more findings

<a id="plus-ampersand-op"/><a id="numeric-and"/>
**+&**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
bitwise *[AND](appendix-g-glossary.html#and)*,
forces [numeric context](appendix-g-glossary.html#numeric-context)

<a id="plus-plus-op"/><a id="auto-increment"/>
**++**
*[«sequence traversal»](tablet-4-operators.html#traversing-sequence)* &mdash;
generic autoincrement, changes this value to its next neighbour in its ordered set,
can be used as [prefix](#prefix_category) (take effect before 
[evaluating](appendix-g-glossary.html#evaluation) the surrounding term)
or [suffix](#suffix_category) (incrementing afterwards),
alias to **[succ](#succ)**, opposite of **[--](#auto-decrement)**

<a id="plus-lower-op"/>
**+<**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
shift left in [numeric context](appendix-g-glossary.html#numeric-context)

<a id="plus-greater-op"/>
**+\>**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
shift right in [numeric context](appendix-g-glossary.html#numeric-context)

<a id="plus-caret-op"/><a id="numeric-xor"/>
**+\^**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
[infix](#infix-category) bitwise *[XOR](appendix-g-glossary.html#xor)*,
that looks at ot operands in [numeric context](appendix-g-glossary.html#numeric-context)

<a id="plus-pipe-op"/><a id="numeric-or"/>
**+|**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
[infix](#infix-category) bitwise *[OR](appendix-g-glossary.html#or)*,
forces [numeric context](appendix-g-glossary.html#numeric-context)

<a id="comma"/><a id="comma-op"/>
**[,](tablet-3-variables#array)** 
[«list op»](tablet-4-operators.html#list-generation) &mdash;
[list](tablet-3-variables#array)-generating operator

<a id="minus"/><a id="minus-op"/>
**-**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
[infix](#infix-category) subtraction operator,
forces [numeric context](appendix-g-glossary.html#numeric-context) on both operands
and does so (and negates) if used only as [*prefix*](#prefix-category),
opposite of [**+**](#plus-op)

<a id="minus-minus-op"/><a id="auto-decrement"/>
**--**
*[«sequence traversal»](tablet-4-operators.html#traversing-sequence)* &mdash;
generic autodecrement, changes this value to its previous neighbour in its ordered set,
can be used as [prefix](#prefix_category) (take effect before 
[evaluating](appendix-g-glossary.html#evaluation) the surrounding term)
or [suffix](#suffix_category) (incrementing afterwards),
alias to **[pred](#pred)**, opposite of **[++](#<a id="auto-increment"/>)**

<a id="minus-minus-greater-signature"/>
**--\>**
*[«signature symbol»](appendix-b-grouped.html#signature-symbols)* &mdash;
declares the type of the return value of a
*[routine](appendix-g-glossary#routine)*, type name is placed after
this arrow at the end of a signature

<a id="minus-greater-signature"/>
**-\>**
*[«signature symbol»](appendix-b-grouped.html#signature-symbols)* &mdash;
declares named parameters for a *[block](appendix-g-glossary.html#block)*
(pointy block)

<a id="dot"/><a id="dot-twigil"/>
**.**
*[«twigil»](appendix-b-grouped.html#twigils)* &mdash;
*[twigil](appendix-g-glossary.html#twigil)* of public accessors
(getter/setter methods)

<a id="dot-metachar"/>
**.**
*[«regex metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
matches one character, any character
(including a [**\\n**](#backslash-n) - unlike in Perl 5)

<a id="dot-subrule"/>
\<**.**<span class="you-provide">s</span>\> &mdash;
prefix for a *[subrule](appendix-g-glossary.html#subrule)*
that doesn't capture (matches will not be remembered)

<a id="dot-dot"/><a id="dot-dot-op"/><a id="range-op"/>
**..**
*[«ranges»](tablet-4-operators.html#ranges)*,
*[«list op»](tablet-4-operators.html#list-generation)* &mdash;
[infix](#infix-category) range generating operator,
produces a **[Range](#Range-type)** object in
[item context](appendix-b-grouped.html#contextualizers)
which generate lists in [list context](appendix-g-glossary.html#list-context)

<a id="dot-dot-dot"/><a id="dot-dot-dot-op"/><a id="sequence-op"/>
**[...](tablet-4-operators.html#sequence-operator)**
*[«list op»](tablet-4-operators.html#list-generation)* &mdash;
*[infix](#infix-category)* [sequence](appendix-g-glossary.html#sequance) 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 &mdash;
example: `@a = 1, 2, 4 ...` infite lazy list of all powers of two, 
`1, 1, *+*, ... 1000` returns fibonacci numbers lower equal then 1000

<a id="dot-yadda"/>
**...**
*[«yadda op»](tablet-4-operators.html#yadda)* &mdash;
[yadda operator](appendix-g-glossary.html#yadda-operator) that calls
**[fail](#fail)** (exception),
marks unimplemented empty *[routine](appendix-g-glossary.html#routine)*
bodies

<a id="slash-op"/>
**/** *[«numeric op»](tablet-4-operators.html#numeric-context)*
infix division,
forces [numeric context](appendix-g-glossary.html#numeric-context)

<a id="slash-composer"/>
**/** *[«rat composer»](tablet-2-basic-syntax.html#rational-number)*
inside round brackets (for example `(3/7)`), gives you a
[rational number](#Rat-type) that keeps track of its numerator and denominator

<a id="slash-var"/><a id="match-var"/><a id="match-object"/>
**$/** 
*[«special var»](appendix-b-grouped.html#match-variables)* &mdash;
last created match object of this [*block*](appendix-g-glossary.html#block)
with the [following methods](appendix-b-grouped.html#match-object-methods)

<a id="slash-slash-op"/><a id="defined-or"/>
**//**
*[«logical op»](tablet-4-operators.html#logical-selection)* &mdash;
short circuit *defined or*, returns the first defined value
(from left to right), similar to **[||](#pipe-pipe-op)** &mdash;
high precedence version of **[err](#err)**



# [0](#nav-top)

<a id="backslash-0"/><a id="backslash-zero"/>
**\\0**<span class="you-provide">s</span>**\[**<span class="you-provide">n</span>**]**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash; 
character given in octal, decimal or hex (when <span class="you-provide">s</span>
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

<a id="0-var"/><a id="zero-var"/><a id="number-var"/>
**$0**
*[«special var»](appendix-b-grouped.html#match-variables)* &mdash;
first positional submatch, there is **`$1`**, **`$2`**, ... too
(don't stops at **`$9`** like Perl 5), alias to
[**`$()[0]`**](#round-brackets-var) and
[**`$/[0]`**](#slash-var), Perl 5: *\$0* is 
[**\$\*EXECUTABLE\_NAME**](#EXECUTABLE-NAME-global-var)

<a id="colon"/><a id="colon-adverb"/>
**:**<span class="you-provide">s</span>(<span class="you-provide">s</span>) &mdash;
*[pair](#Pair-type)* generation operator,
also known as *adverbial* syntax &mdash;
example: *`$pair = :key('value')`*

<a id="colon-test"/>
**:**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
start of all test methods
(r w x o R W X O e z s f d l p S b c t u g k T B M A C)
in the adverbial form &mdash;
example: *`$filename.IO ~~ :X`*

<a id="colon-twigil"/>
**:**
*[«twigil»](appendix-b-grouped.html#twigils)* &mdash;
*[twigil](appendix-g-glossary.html#twigil)* of autogenerated named
parameters of a *[block](appendix-g-glossary.html#block)*

<a id="colon-numeric"/>
**:**<span class="you-provide">N</span>\<<span class="you-provide">n</span>\> &mdash;
[general radix form](tablet-2-basic-syntax.html#general-radix-form)
for literals, makes a number <span class="you-provide">n</span> in base
<span class="you-provide">N</span> (up to 36) &mdash;
example: `:2<1000001>` is decimal 65

<a id="colon-label"/>
**:**<span class="you-provide">s</span> *«flow control»* &mdash;
suffix of all labels you can jump to with **[goto](#goto)**

<a id="colon-signature"/>
**:**
*[«signature symbol»](appendix-b-grouped.html#signature-symbols)* &mdash;
prefix of a *[named parameter](appendix-g-glossary.html#named-parameter)* in
a signature, they are positional when without colon

<a id="colon-colon-sigil"/>
**::**
*[«sigil»](appendix-b-grouped.html#sigils)* &mdash;
abstraction [sigil](appendix-g-glossary.html#sigil) and namespace
separator in variable / [routine](appendix-g-glossary.html#routine) /
namespace names (like in Perl 5)

<a id="colon-colon-signature"/>
**::**
*[«signature symbol»](appendix-b-grouped.html#signature-symbols)* &mdash;
introducing a type variable in a signature

<a id="colon-colon-equal-op"/><a id="compiletime-binding-op"/>
**[::=](tablet-3-variables#binding)** &mdash;
[binds](tablet-3-variables#binding)
a value or variable to a variable at compile time

<a id="colon-equal-op"/><a id="runtime-binding-op"/>
**[:=](tablet-3-variables#binding)** &mdash;
creates an alias to a variable at runtime
(*[binding](tablet-3-variables#binding)*)

<a id="semicolon"/><a id="semicolon-terminator"/>
**[;](tablet-2-basic-syntax.html#statements)**
*«terminator»* &mdash;
separates [statements](tablet-2-basic-syntax.html#statements)
(commands) or [array indices](tablet-3-variables#array-slices) &mdash;
example: `@[2;3]` instead of `@a[2][3]`

<a id="lower-op"/>
**\<**
*[«num comparison»](tablet-4-operators.html#numerical-comparison)* &mdash;
[infix](#infix-category) op, less than,
**[True](#True)** if numerically ordered the left
comes before the right operand

<a id="lower-minus-greater-signature"/>
**<-\>**
*[«signature symbol»](appendix-b-grouped.html#signature-symbols)* &mdash;
double pointy syntax to assign a rw parameter to a
*[block](appendix-g-glossary.html#block)*

<a id="lower-lower-metaop"/><a id="left-hyperop"/>
**\<\<**
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
hyper metaopeartor, right side dicates the lengths of the  result,
has a [unicode sibling](appendix-b-grouped.html#unicode-operators) &mdash;
example: `2 <<+=<< @b` increments numeric value of every array element by 2

<a id="lower-lower-equal-equal-op"/><a id="appending-left-pipe-op"/>
**\<\<==**
*[«sequencer op»](tablet-4-operators.html#feed-ops)* &mdash;
leftward pointing feed operator that adds values to an existing list (append-mode) &mdash;
see also: [*\<==*](#lower-lower-equal-op) and [*==\>\>*](#equal-equal-greater-greater-op)

<a id="double-angle-brackets"/><a id="double-angle-brackets-op"/>
<a id="texas-brackets"/><a id="texas-brackets-op"/>
<a id="french-brackets"/><a id="french-brackets-op"/>
**[\<\< \>\>](tablet-2-basic-syntax.html#quote-words)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
[circumfix](#circumfix-category) quoting operator to autoquote of words and return
them as a list, with [quote protection](appendix-g-glossary.html#quote-protection)
and [evaluation](appendix-g-glossary.html#evaluation) of variables,
alias to: **Q** **[:qq](#qq-adverb)** **[:ww](#ww-adverb)** **/.../**
or `« »` ([unicode](appendix-g-glossary.html#unicode) alias) &mdash;
see also: [**\< \>**](#angle-brackets-op)

<a id="lower-equal"/><a id="lower-equal-op"/>
**\<=**
*[«num comparison»](tablet-4-operators.html#numerical-comparison)* &mdash;
less than or equal, numeric comparison operator &mdash;
see also: [**<**](#lower-op) and [**\>=**](#greater-equal-op)

<a id="lower-equal-equal-op"/><a id="left-pipe-op"/>
**\<==**
*[«sequencer op»](tablet-4-operators.html#feed-ops)* &mdash;
leftward pointing feed operator, take return value of right side
and feed as parameter to the left &mdash;
see also: **[==\>](#equal-equal-greater-op)**

<a id="lower-equal-greater-op"/><a id="spaceship-op"/>
**\<=\>**
*[«num comparison»](tablet-4-operators.html#numerical-comparison)* &mdash;
numeric, *[infix](#infix-category)* less-equal-greater comparison for sortable classes,
so called "spaceship operator", does a **[cmp](#cmp)** of the into 
[numeric context](appendix-g-glossary.html#numeric-context) converted values of both sides,
as **[leg](#leg)** does in *[string](#Str-type)* context &mdash;
example: `3 <=> 4` returns `-1`, `3 <=> 3` returns `0`, `4 <=> 3` returns `1`

<a id="angle-brackets"/><a id="angle-brackets-op"/>
**[\< \>](tablet-2-basic-syntax.html#quote-words)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
[circumfix](#circumfix-category) quoting operator that autoquotes words
and returns them as a list,
without [quote protection](appendix-g-glossary.html#quote-protection) and
evaluation of variables like [\<\< \>\>](#double-angle-brackets),
alias to **[qw/.../](#qw-op)** or
**[Q](#Q-op)** **:q** **[:ww](#ww-adverb)** **/.../**

<a id="angle-brackets-twigil"/><a id="angle-brackets-var"/>
**\< \>**
*[«twigil»](appendix-b-grouped.html#twigils)* &mdash;
[circumfix](#circumfix-category)
*[twigil](appendix-g-glossary.html#twigil)* of named captures, **`$<...>`**
is alias to [**`$/<...>`**](#match-var), in Perl 5: *$&* and *$MATCH*

<a id="angle-brackets-metachar"/>
**\< \>**
*[«regex metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
embraces an subrule (assertion),
if it doesn't start wit a **.**, **?** or **!** findings will stored under the
name of the subrule as [*named capures*](appendix-g-glossary.html#named-capure)
into [`$/<name>`](#match-var) and [`$<name>`](#angle-brackets-var)


# [=](#nav-top)

<a id="equal"/><a id="equal-op"/>
**[=](tablet-3-variables#assignment)**
*«Op»* &mdash;
[assignment](tablet-3-variables#assignment),
right side is [evaluated](appendix-g-glossary.html#evaluation) and assigned
to the left

<a id="equal-twigil"/>
**=**
*[«twigil»](appendix-b-grouped.html#twigils)* &mdash;
[POD](appendix-g-glossary.html#POD) variable, mapped content from POD
sections of this file &mdash;
examples:
[**`$=pod`**](#pod-pod-var) and
[**`$=data`**](#data-pod-var)

<a id="equal-metaop"/>
<span class="you-provide">op</span>**=**
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
self assignment, left side is one operand and place where the
result is assigned to &mdash;
example: `$a += 3;` equals `$a = $a + 3`

<a id="equal-colon-equal-op"/>
**=:=** *«comparison op»* &mdash;
compares [binding](tablet-3-variables#binding),
if both vars are bound to same memory location

<a id="equal-equal"/><a id="equal-equal-op"/>
**==**
*[«num comparison»](tablet-4-operators.html#numerical-comparison)* &mdash;
**[True](#True)** if values are equal in [numeric context](appendix-g-glossary.html#numeric-context),
as **[eq](#eq)** does in *[string context](tablet-4-operators.html#string-context)*

<a id="equal-equal-equal"/><a id="equal-equal-equal-op"/><a id="identity-op"/>
**===** *«comparison op»* &mdash;
*[infix](#infix-category)* check for identity - equality of
value and [type](appendix-b-grouped.html#value-types)

<a id="equal-equal-greater-op"/><a id="pipe-right"/>
**==\>**
*[«sequencer op»](tablet-4-operators.html#feed-ops)* &mdash;
rightward pointing feed operator, take return value of left side
and feed as parameter to the right &mdash;
see also: [*\<==*](#lower-equal-equal-op) and [*==\>\>*](#equal-equal-greater-greater-op)

<a id="equal-equal-greater-greater-op"/>
**==\>\>**
*[«sequencer op»](tablet-4-operators.html#feed-ops)* &mdash;
rightward pointing feed operator that adds values to an existing list (append-mode) &mdash;
see also: [*==\>*](#equal-equal-greater-op) and [*\<\<==*](#lower-lower-equal-equal-op)

<a id="equal-greater-op"/><a id="fat-arrow"/>
**=\>**
*«op»* &mdash;
**[Pair](#Pair-type)** (and Hash) constructor called *fat arrow* &mdash;
example: `$pair = 'key' => 'value';` &mdash;
alternative to the *[adverbial syntax](#colon-adverb)*

<a id="greater-op"/>
**\>**
*[«num comparison»](tablet-4-operators.html#numerical-comparison)* &mdash;
*[infix](#infix-category)* op, numeric greater than

<a id="greater-equal-op"/>
**\>=** *[«num comparison»](tablet-4-operators.html#numerical-comparison)*
*[infix](#infix-category)* comparison op, numeric greater than or equal

<a id="greater-greater-metaop"/><a id="right-hyperop"/>
**\>\>**
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
hyper metaopeartor, left side dicates the lengths of the  result,
has a [unicode sibling](appendix-b-grouped.html#unicode-operators) &mdash;
example: `@a >>++` increments numeric value of every array element



# [?](#nav-top)

<a id="question"/><a id="question-op"/><a id="question-context"/>
**[?](tablet-4-operators.html#logical-selection)**
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
forces *[boolean context](tablet-4-operators.html#bool-context)*
in an expression, returns **[False](#False)** when
value is 0 or empty, otherwise **[True](#True)**,
high precedence version of **[so](#so)**

<a id="question-signature"/>
**?**
*[«signature symbol»](appendix-b-grouped.html#signature-symbols)* &mdash;
suffix for optional named parameters in signatures

<a id="question-metachar"/>
**?**
*[«regex metachar»](appendix-b-grouped.html#quantifier)* &mdash;
quantifier for 0 or 1 occurrence in Regexes

<a id="question-twigil"/>
**?**
*[«twigil»](appendix-b-grouped.html#twigils)* &mdash;
*[twigil](appendix-g-glossary.html#twigil)* (secondary sigil) for
constant compiler hint variables

<a id="question-assertion"/>
**?**
*[«regex metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
a leading **?** in a [*subrule*](appendix-g-glossary.html#subrule) indicates
a positive zero-width assertion like
[**<?before ...>*](#before-subrule), opposite of [**!**](#exclamation-assertion)


<a id="question-subrule"/>
**\<?\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
matches nothing, returns always **[True](#True)**,
opposite of [**\<!\>**](#exclamation-subrule)

<a id="question-ampersand-op"/><a id="boolean-and"/>
**?&**
*[«bool op»](tablet-4-operators.html#bool-context)* &mdash;
logical *[AND](appendix-g-glossary.html#and)* op,
forces [boolean context](appendix-g-glossary.html#bool-context)

<a id="question-question"/><a id="question-question-exclamation-exclamation"/>
<a id="conditional-op"/><a id="ternary-op"/>
**?? !!**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
ternary or conditional operator,
shortcut for **[if](#if)** and
**[else](#else)** &mdash;
see also: [**||**](#logical-or), [**ff**](#ff), [**fff**](#fff)

<a id="question-question-question"/><a id="question-question-question-op"/>
<a id="question-yadda"/>
**???**
*[«yadda op»](tablet-4-operators.html#yadda)* &mdash;
[yadda operator](appendix-g-glossary.html#yadda-operator)
that calls **[warn](#warn)**

<a id="question-caret-op"/><a id="boolean-xor"/>
**?\^**
*[«bool op»](tablet-4-operators.html#bool-context)* &mdash;
logical *[infix](#infix-category)* *[XOR](appendix-g-glossary.html#xor)*,
forces operands into [boolean context](appendix-g-glossary.html#bool-context)

<a id="question-pipe-op"/><a id="boolean-or"/>
**?|**
*[«bool op»](tablet-4-operators.html#bool-context)* &mdash;
*[infix](#infix-category)* logical *[OR](appendix-g-glossary.html#or)*,
forces operands into [boolean context](appendix-g-glossary.html#bool-context)

<a id="at"/><a id="at-sigil"/>
**@**
*[«sigil»](appendix-b-grouped.html#sigils)* &mdash;
[sigil](appendix-g-glossary.html#sigil) of an [array](tablet-3-variables#array)

<a id="at-op"/><a id="at-context"/><a id="array-context-op"/>
**@**()
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
forces (flattened) [array context](appendix-g-glossary.html#array-context),
alias to **[list()](#list)** function

<a id="postcircumfix-square-brackets-op"/><a id="slice-op"/>
<span class="you-provide">var</span>**\[ \]** &mdash;
[postcircumfix](#postcircumfix-category) operator,
appended on an array var, returns an array slice with values which
indexes was inside the brackets

<a id="square-brackets-op"/><a id="array-ref"/>
**[**<span class="you-provide">l</span>**]** &mdash; [circumfix](#circumfix-category) operator
that creates a reference to an array that holds all values that
encompas these brackets

<a id="square-brackets-metachar"/>
**[**<span class="you-provide">p</span>**]**
*[«regex metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
encompass a *subregex*, results will not be remembered like with
[**( )**](#round-brackets-metachar)

<a id="square-brackets-metaop"/><a id="reduce-op"/>
**\[**<span class="you-provide">op</span>**\]**
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
[circumfix](#circumfix-category) reduction
metaop, applies the operator between all elements of an array,
alias to [**reduce**](#reduce)

<a id="square-brackets-backslash-metaop"/><a id="triangle-op"/>
**\[\\**<span class="you-provide">op</span>**\]**
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
[circumfix](#circumfix-category) 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](#triangle)**

<a id="backslash"/><a id="backslash-op"/>
**\\** &mdash;
[capture generator](tablet-3-variables#capture),
creates a *[capture](appendix-g-glossary.html#capture)*
that holds the following structure

<a id="backslash-metachar"/><a id="escape-char"/>
**\\** *«escape char»* &mdash;
all escape sequences with a width 
inside [quotes](appendix-b-grouped.html#control-chars)
and [regexes](appendix-b-grouped.html#escape-sequences) start with it



# [\^](#nav-top)

<a id="caret"/><a id="caret-op"/><a id="junctive-xor"/>
**\^**
*[«junctive op»](tablet-4-operators.html#junctions)* &mdash;
 *[infix](#infix-category)* *[junctive](appendix-g-glossary.html#junction)*
 *[XOR](appendix-g-glossary.html#xor)*,
requires that exactly one of both operands is **[True](#True)** in 
[*bool context*](appendix-g-glossary.html#bool-context) to return **True** &mdash;
see also **[one](#one)**

<a id="caret-upto"/>
**\^** &mdash; upto operator, `^$limit` expands to `0 ..^ +$limit` [range](#range-op)

<a id="caret-range"/>
**\^**
*[«ranges»](tablet-4-operators.html#ranges)* &mdash;
in [range](#range-op) definitions,
it excludes a limit value  in [scalar context](appendix-g-glossary.html#scalar-context) &mdash;
see also: [~~]()

<a id="caret-twigil"/>
**\^**
*[«twigil»](appendix-b-grouped.html#twigils)* &mdash;
autogenerated positional parameters of a
*[block](appendix-g-glossary.html#block)*, position results from
alphabetical order of all $\^-Variables

<a id="caret-signature"/>
**\^**
*[«signature symbol»](appendix-b-grouped.html#signature-symbols)* &mdash;
prefix of metaclass methods, `$obj.^methods();` is shortcut for
[`$obj.HOW.methods($obj);`](#HOW-introspection)

<a id="caret-metachar"/>
**\^**
*[«regex Metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
start of the string

<a id="caret-caret-op"/><a id="logical-xor"/>
**\^\^**
*[«logical op»](tablet-4-operators.html#logical-selection)* &mdash;
[infix](#infix-category) logical ([*XOR*](appendix-g-glossary.html#xor)) operator
that operates with into [*bool context*](appendix-g-glossary.html#bool-context)
converted values of both operands without changing their content,
in *bool context* it returns [**True**](#True) or **False** as expected,
in any other context it returns the first none empty value, 
the second when both are empty and [**Nil**](#Nil-type) when both are not empty,
[high precedence](appendix-b-grouped.html#table-of-precedence) version of [**xor**](#xor) &mdash;
example: `('dang' ^^ '')` returns `'dang'`

<a id="doule-caret-metachar"/>
**\^\^**
*[«regex Metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
start of a line

<a id="context-var"/><a id="underscore-var"/>
**$\_**
*[«special var»](appendix-b-grouped.html#special-variables)* &mdash;
context var, result of the last command, can set by topicalizers
(**[given](#given)** and **[for](#for)**)

<a id="curly-brackets"/><a id="curly-brackets-terminator"/>
**{}**
«terminator» &mdash;
[circumfix](#circumfix-category) operator,
encloses blocks and creates a *[coderef](appendix-g-glossary.html#coderef)*,
or a hashref when it is identified as a hash or contains a **[=\>](#fat-arrow)**

<a id="pipe"/><a id="pipe-op"/><a id="junctive-or"/>
**|**
*[«junctive op»](tablet-4-operators.html#junctions)* &mdash;
*[junctive](appendix-g-glossary.html#junction)* *[OR](appendix-g-glossary.html#or)*,
requires that a condition is fulfilled &mdash;
see also: **[any](#any)**

<a id="pipe-metachar"/>
**|**
*[«regex Metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash; 
match alternate patterns with longest token matching
(*[OR](appendix-g-glossary.html#or)* - temporal simultaneous connection of patterns)

<a id="pipe-context"/>
**|**()
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
flatten [capture](tablet-3-variables#capture)
object into arglist, (named parameter)

<a id="pipe-pipe-op"/><a id="logical-or"/>
**||**
*[«logical op»](tablet-4-operators.html#logical-selection)* &mdash;
*[infix](#infix-category)* short circuit logical *[OR](appendix-g-glossary.html#or)*, 
[evaluates](appendix-g-glossary.html#evaluation) sequentially left to right
its operands until one is [**True**](#True) in 
[*bool context*](appendix-g-glossary.html#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](#or)** &mdash;
example: `(3 || 5)` returns `3` &mdash;
see also: [**|**](#junctive-or), [**?? !!**](#ternary-op)

<a id="pipe-pipe-metachar"/>
**||**
*[«regex Metachar»](appendix-b-grouped.html#regex-metacharacter)* &mdash;
match alternate patterns (temporal consequent alternatives) as
connected with a logical *[OR](appendix-g-glossary.html#or)*

<a id="pipe-pipe-context"/>
**||**()
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
flatten [capture](tablet-3-variables#capture)
object into semicolon list, (positional parameter)

<a id="tilde"/><a id="tilde-op"/><a id="tilde-context"/>
**[\~](tablet-4-operators.html#string-context)**
*[«context op»](appendix-b-grouped.html#contextualizers)*,
*[«string op»](tablet-4-operators.html#string-context)*,
forces *[string context](appendix-g-glossary.html#string-context)*
on its operands (stringifies),
if *[infix](#infix-category)* its concatenate strings -
an alias for **[cat](#cat)**

<a id="tilde-twigil"/>
**\~**
*[«twigil»](appendix-b-grouped.html#twigils)* &mdash;
*[twigil](appendix-g-glossary.html#twigil)* for a
[grammar](#grammar) of a sublanguage like
**[$\~MAIN](#MAIN-slang-var)**

<a id="tilde-ampersand-op"/><a id="string-and"/>
**\~&** *[«string op»](tablet-4-operators.html#string-context)* &mdash;
characterwise *[AND](appendix-g-glossary.html#and)*,
forces *[string context](appendix-g-glossary.html#string-context)*

<a id="tilde-lower-op"/>
**\~<** *[«string op»](tablet-4-operators.html#string-context)* &mdash;
characterwise left shift,
forces *[string context](appendix-g-glossary.html#string-context)*

<a id="tilde-greater-op"/>
**\~\>** *[«string op»](tablet-4-operators.html#string-context)* &mdash;
characterwise right shift,
forces *[string context](appendix-g-glossary.html#string-context)*

<a id="tilde-caret-op"/><a id="string-xor"/>
**\~\^** *[«string op»](tablet-4-operators.html#string-context)* &mdash;
characterwise *[XOR](appendix-g-glossary.html#xor)*,
forces *[string context](appendix-g-glossary.html#string-context)*

<a id="tilde-pipe-op"/><a id="string-or"/>
**\~|** *[«string op»](tablet-4-operators.html#string-context)* &mdash;
characterwise *[OR](appendix-g-glossary.html#or)*,
forces *[string context](appendix-g-glossary.html#string-context)*

<a id="tilde-tilde-op"/><a id="smartmatch-op"/>
**[\~\~](tablet-4-operators.html#smartmatch)**
*«comparison op»* &mdash;
[*infix*](#infix-category) [*smartmatch*](appendix-g-glossary.html#smartmatch) operator, 
compares (almost) all variable and data types according a
[table](appendix-b-grouped.html#smartmatch)



# [A](#nav-top)

<a id="a-adverb"/>
**:a**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
demands [evaluation](appendix-g-glossary.html#evaluation) of array variables,
that starting with the
**[@-sigil](#at-sigil)**, short form of
**[:array](#array-adverb)**, included in
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="abs"/>
**abs** *«numeric op»* &mdash;
returns numeric absolute value,
converts value into [*numeric context*](appendix-g-glossary.html#numeric-context) &mdash;
example: `abs -4.76` returns `4.76` as does `abs 4.76` &mdash;
see also: [**round**](#round), [**sign**](#sign), [**truncate**](#truncate)

<a id="after"/>
**after**
*[«generic comparison»](tablet-4-operators.html#generic-comparison)* &mdash;
generic comparison operator used by the Order class,
**[True](#True)** if left should follow right

<a id="after-negative-subrule"/>
**\<!after <span class="you-provide">p</span>\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
negative zero-width lookbehind, if before this position is
something that matches the pattern inside the angle brackets, the
whole pattern will not match

<a id="after-subrule"/>
**\<?after <span class="you-provide">p</span>\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
positive zero-width lookbehind, only if this position is
preceded by the given pattern inside the angle brackets, the whole
pattern will match

<a id="all"/>
**all**
*[«junctive op»](tablet-4-operators.html#junctions)* &mdash;
*[junctive](appendix-g-glossary.html#junction)*
*[AND](appendix-g-glossary.html#and)* operator,
**[True](#True)** if all conditions (elements of a following list) are fulfilled &mdash;
see also: [**&**](#junctive-and)

<a id="alnum-subrule"/>
**\<alnum\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
a single alphanumeric character,
equivalent to **\<+[alpha](#alpha-subrule) +[digit](#digit-subrule)\>**

<a id="alpha-subrule"/>
**\<alpha\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
a single alphabetic character

<a id="and"/>
**and**
*[«logical op»](tablet-4-operators.html#logical-selection)* &mdash;
*[infix](#infix-category)* short circuit logical *[AND](appendix-g-glossary.html#and)*,
[evaluates](appendix-g-glossary.html#evaluation) sequentially left to right
its operands until one is [**False**](#False) in
[*boolean context*](appendix-g-glossary.html#boolean-context),
if one was **False** the result in *boolean context* is **False**,
otherwise the last evaluated operand,
low precedence version of **[&&](#logical-and)** &mdash;
example: `'hurray' and 0` returns `0` &mdash;
see also: [**andthen**](#andthen), [**all**](#all)

<a id="andthen"/>
**andthen**
*«logical op»* &mdash;
logical *[AND](appendix-g-glossary.html#and)* short circuit operator,
transferring **[$\_](#context-var)** from first to second block or expression,
if first did succeed &mdash;
example: `{...} andthen { .say }` &mdash;
see also: [**orelse**](#orelse), [**and**](#orelse)

<a id="anon"/>
**anon**
*[«scope declarator»](appendix-b-grouped.html#scope-declarator)* &mdash;
introduces names that aren't to be stored anywhere (anonymous)

<a id="Any"/><a id="Any-type"/>
**Any**
*[«undefined value type»](appendix-b-grouped.html#undefined-types)* &mdash;
Perl 6 object (default *[routine](appendix-g-glossary.html#routine)*
*[parameter](appendix-g-glossary.html#parameter)* type, excludes
*[junctions](appendix-g-glossary.html#junction)*)

<a id="any"/>
**any**
*[«junctive op»](tablet-4-operators.html#junctions)* &mdash; 
*[junctive](#junction)* *[OR](appendix-g-glossary.html#or)* operator,
**[True](#True)** when any one condition (of a
following list) is true in [*boolean context*](appendix-g-glossary.html#bool-context)  &mdash;
see also: [**|**](#junctive-or)

<a id="ARGFILES-global-var"/>
**$\*ARGFILES**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash; 
magic command-line input handle, in Perl 5: *ARGV*

<a id="ARGS-global-var"/>
**@\*ARGS**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash; 
arguments (parameter) to a program (script), in Perl 5: *@ARGV*

<a id="args"/>
**args**
*[«callframe method»](appendix-b-grouped.html#callframe-methods)* &mdash;

<a id="arity"/>
**arity**
*«routine method»* &mdash;
returns how many *[parameters](appendix-g-glossary.html#parameter)* 
this *[routine](appendix-g-glossary.html#routine)*
requires, **[.count](#count)** includes also the optional

<a id="Array-type"/>
**Array**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
Perl Array, a series of **[Scalar](#Scalar-type)**
value container, or a variable that stores such a list

<a id="array-adverb"/>
**[:array](tablet-2-basic-syntax.html#interpolation)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
demands [evaluation](appendix-g-glossary.html#evaluation) of array variables
that starting with the
**[@-sigil](#at-sigil)**, long form of
**[:a](#a-adverb)**, included in
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="as-parameter-trait"/>
**as**
*[«parameter trait»](appendix-b-grouped.html#parameter-traits)* &mdash;
data coming through that parameter will be coerced to the type
following **as**

<a id="as-routine-trait"/>
**as**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
inner type constraint that a *[routine](appendix-g-glossary.html#routine)*
imposes on its return value

<a id="assertion-category"/>
**assertion**
*[«grammatical category»](appendix-b-grouped.html#regex)* &mdash;
namespace for [*regex*](appendix-g-glossary.html#regex) assertions
like [**!**](#exclamation-assertion)

<a id="assoc"/>
**assoc**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
specifies the [associativity of an
operator](appendix-b-grouped.html#operator-associativity)
explicitly

<a id="assuming"/>
**assuming** &mdash;
method of all *[routine](appendix-g-glossary.html#routine)*
objects that enables *[Currying](appendix-g-glossary.html#currying)*

<a id="async"/>
**async** *«block modifier»* &mdash;
allows the interpreter to parallelize the following term

<a id="augment"/>
**augment**
*[«scope declarator»](appendix-b-grouped.html#scope-declarator)* &mdash;
adds definitions to an existing name, inserts new methods and
attributes into a **[grammar](#grammar)** or
replaces them, see also: **[supersede](#supersede)**



# [B](#nav-top)

<a id="b-test"/>
**:b**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
file is a block special file (e.g. Harddisks, CDROMs and RAM areas)

<a id="b-adverb"/>
**:b**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
forces evaluation of
[escape sequences](appendix-b-grouped.html#escape-sequences),
short form of **[:backslash](#backslash-adverb)**,
included in **["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="backslash-category"/>
**backslash**
*[«grammatical category»](appendix-b-grouped.html#regex)* &mdash;
internal namespace for [*escape sequences*](appendix-b-grouped.html#escape-sequences)
like [**\\w**](#backslash-w)

<a id="backslash-adverb"/>
**[:backslash](tablet-2-basic-syntax.html#interpolation)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
forces evaluation of [escape
sequences](appendix-b-grouped.html#escape-sequences)
, long form of **[:b](#b-adverb)**, included in
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="Bag-type"/>
**Bag**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
unordered collection of values that allows duplicates

<a id="base"/>
**base** &mdash;
returns a **[Str](#Str-type)**
representing the invocant in base $base (only parameter); Fails if
$base is smaller than 2 or larger than 36

<a id="before"/>
**before**
*[«generic comparison»](tablet-4-operators.html#generic-comparison)* &mdash;
generic comparison operator used by the Order class,
**[True](#True)** when left should precede right

<a id="before-negative-subrule"/>
**\<!before <span class="you-provide">p</span>\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
negative zero-width lookahead, if after this position follows
the given pattern inside the angle brackets, the whole pattern will
not match

<a id="before-subrule"/>
**\<?before <span class="you-provide">p</span>\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash; 
positive zero-width lookahead, only if this position is followed
by the given pattern inside the angle brackets, the whole pattern
will match

<a id="BEGIN-phaser"/>
**BEGIN**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block or statement, executed at
*[compile time](appendix-g-glossary.html#compile-time)*,
[ASAP](appendix-g-glossary.html#ASAP), only ever runs once

<a id="Bit-type"/>
**Bit**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
Perl single bit (allows traits, aliasing, undef, etc.)

<a id="blank-subrule"/>
**\<blank\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
a single "blank" character, in most locales, this corresponds
to space and tab

<a id="bless"/>
**bless** &mdash;
calling bless on any invocant (but typically a type object)
to create a new object with the same class as the
*[invocant](appendix-g-glossary.html#invocant)*

<a id="Blob-type"/>
**Blob**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
An undifferentiated mass of bits

<a id="Block-type"/>
**Block**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
executable objects that have
lexical *[scopes](appendix-g-glossary.html#scope)*

<a id="BLOCK-compiler-var"/>
**&?BLOCK** 
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
reference to current block

<a id="Bool-type"/>
**Bool**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
Perl boolean, type of values that can be either
**[True](#True)** or **[False](#False)**
which is in full length *Bool::True* and *Bool::False*

<a id="break"/>
**break**
*[«flow control»](appendix-b-grouped.html#jump-commands)* &mdash;
leave this **[when](#when)** block now, see also:
**[last](#last)** and
**[leave](#leave)**

<a id="Buf-type"/>
**Buf**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
Perl buffer (a stringish array of memory locations), type for
raw binary data

<a id="but"/>
**but** &mdash; adds a **[role](#role)** to a **[class](#class)**

<a id="bytes"/>
**bytes** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*«string method»* &mdash;
number of bytes (a sort of Perl 5's *length*) &mdash;
see also: [**chars**](#chars), [**codes**](#codes), [**graphs**](#graphs)

<a id="bytes-modifier"/>
**:bytes**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching on byte level &mdash;
see also: 
**[chars](#chars-modifier)**,
**[:codes](#codes-modifier)**,
**[:graphs](#graphs-modifier)**



# [C](#nav-top)

<a id="c-test"/>
**:c**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
file is a character special file (e.g. terminals modems)

<a id="c-adverb"/>
**:c**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
forces evaluation of closures (blocks aka {...}) inside quotes,
long form of **[:closure](#closure-adverb)**,
included in **["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="c-modifier"/>
**:c**(<span class="you-provide">n</span>)
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching from nth (n is an int) position (counting from 0) and
then going to the right, short for ":continue"

<a id="backslash-C"/>
**\\C\[<span class="you-provide">n</span>\]**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)*
any character except the bracketed named or control character

<a id="backslash-c"/>
**\\c\[<span class="you-provide">n</span>\]**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
named character or control character

<a id="pipe-c"/>
**\<|c\>**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
codepoint boundary, zero width space between two
*[unicode](appendix-g-glossary.html#unicode)* codepoints,
opposite is **\<!|c\>** &mdash;
see also: **[\<|g\>](#pipe-g)** and **[\<|w\>](#pipe-w)**

<a id="cached"/><a id="cached-routine-trait"/>
**cached**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
marks a *[routine](appendix-g-glossary.html#routine)* as being memoized

<a id="call"/>
**call** &mdash; execute a *[subroutine](appendix-g-glossary.html#routine)*

<a id="caller"/>
**caller** &mdash;
returns an object that [describes](appendix-b-grouped.html#callframe-methods)
the *[routine](appendix-g-glossary.html#routine)*
from which the current routine was called

<a id="callframe"/>
**callframe** &mdash;
returns an object that describes the current state with a
callframe object, that has the
[following methods](appendix-b-grouped.html#callframe-methods)

<a id="callwith"/>
**callwith** &mdash;
callable-method by which one can call a sub with a
different [signature](appendix-g-glossary.html#signature)

<a id="capitalize"/>
**capitalize** &mdash;
alias to a wordwise *ucfirst* (exists only in Perl 5),
makes first char of every word uppercase, rest lowercase

<a id="Capture-type"/>
**[Capture](tablet-3-variables#capture)**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
type holding arguments for a *[routine](appendix-g-glossary.html#routine)*
call (right-hand side of a binding)

<a id="cat"/>
**cat**
*[«array method»](tablet-3-variables#array-methods)* &mdash;
converts values of a *[list](appendix-g-glossary.html#list-context)* into
*[string context](appendix-g-glossary.html#string-context)*
and joines them like with **[\~](#tilde-op)**,
alias to [`.join('')`](#join)

<a id="CATCH-phaser"/>
**CATCH**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block to catch
**[Exceptions](#Exception-type)**, before
**[LEAVE](#LEAVE-phaser)**

<a id="categorize"/>
**categorize**
*[«array method»](tablet-3-variables#array-methods)* &mdash;
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](#classify)** the return value of the
mapper can be listref to put the value in several categories or
**[Nil](#Nil-type)** to reject the value for
categorisation

<a id="category-category"/>
**category**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
grammatical category of all grammatical categories (metacategory),
useful in case you want to create a new one with a macro

<a id="ceiling"/>
**ceiling**
([Num](#Num-type) $x [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*«num method»* &mdash;
lowest integer not less than $x, rounding up to the next whole number &mdash;
example: `ceiling 5.4` returns `6`, `ceiling -5.4` returns `-5`  &mdash;
see also: [**floor**](#floor), [**round**](#round), [**truncate**](#truncate)

<a id="chr"/>
**chr** ([Int](#Int-type) [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«num method»* &mdash;
convert number into character according a
character table (UTF), reverse of **[ord](#ord)**

<a id="chrs"/>
**chrs** ([Array](#Array-type) [of](#of) [Int](#Int-type) 
         [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«num method»* &mdash;
converts every number to a character with that index and combines them to one string,
plural of **[chr](#chr)**, reverse of **[ords](#ords)**

<a id="chars"/>
**chars** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*«string method»* &mdash;
returns number of characters of a string, in Perl 5: *length* &mdash;
see also: **[bytes](#bytes)**, [**codes**](#codes), [**graphs**](#graphs)

<a id="chars-modifier"/>
**:chars**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching on character level (default), see also:
**[:bytes](#bytes-modifier)**,
**[codes](#codes-modifier)**,
**[graphs](#graphs-modifier)**

<a id="chdir"/>
**[chdir](tablet-5-io.html#dir)**
changes the current working directory
(**[$\*CWD](#CWD-global-var)**)

<a id="CHECK-phaser"/>
**CHECK**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block or statement, executed at
*[compile time](appendix-g-glossary.html#compile-time)*
[ALAP](appendix-g-glossary.html#ALAP), only ever runs once

<a id="chmod"/>
**chmod** &mdash;
changes access rights of files (like on Unix)

<a id="chomp"/>
**chomp** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«string method»* &mdash;
returns a copy of a [string](#Str-type) with the
last newline ([**\\n**](#backslash-n)) (if there is one) removed &mdash;
see also: [**chop**](#chop), [**trim**](#trim)

<a id="chop"/>
**chop** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«string method»* &mdash;
returns a copy of a [string](#Str-type) with the last character removed &mdash;
see also: [**chomp**](#chomp), [**substr**](#substr)

<a id="chown"/>
**chown** &mdash; changes owner of files

<a id="chroot"/>
**[chroot](tablet-5-io.html#chroot)** &mdash;
change root directory on POSIX systems

<a id="cis"/>
**cis** *«Complex method»* &mdash;
see also: [**conj**](#conj), [**polar**](#polar), [**unpolar**](#unpolar)

<a id="circumfix-category"/>
**circumfix** *[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
operator namespace of two parted ops that surround the
statement, op or variable they affect, most prominent example may be
the [double quotes](#double-quotes)

<a id="class"/>
**class** *«block modifier»* &mdash; 
following block will build an object, see also **[method](#method)**,
**[submethod](#submethod)** and **[has](#has)**

<a id="CLASS-compiler-var"/>
**$?CLASS**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
current class object

<a id="CLASS-namespace-compiler-var"/>
**::?CLASS**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
name of the current class

<a id="classify"/>
**classify**
*[«array method»](tablet-3-variables#array-methods)* &mdash;
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](#categorize)**)

<a id="close"/>
**[close](tablet-5-io.html#close)**
*«filehandle method»* &mdash;
releasing the connection to a file via a [*file handle*](IO-type)

<a id="closure-adverb"/>
**[:closure](tablet-2-basic-syntax.html#interpolation)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
forces evaluation of closures (blocks aka {... }) inside quotes,
long form of **[:c](#c-adverb)**, included in
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="cmp"/><a id="cmp-op"/>
**cmp**
*[«generic comparison»](tablet-4-operators.html#generic-comparison)* &mdash;
general [infix](#infix-category) sort comparator,
result is *Order::Increase* (numerically -1) if
**[before](#before)** is **[True](#True)** (left side is ordered before right) -
*Order::Same* (numerically 0) if **[eqv](#eqv)** - 
*Order::Decrease* (numerically 1) if **[after](#after)** &mdash;
see also: **[leg](#leg)** and **[\<=\>](#spaceship-op)**)



# [Cn](#nav-top)

<a id="cntrl-subrule"/>
**\<cntrl\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
a not visible character that is aimed to control the console
output, [the complete list](appendix-b-grouped.html#control-chars)

<a id="code"/><a id="code-context"/><a id="code-op"/>
**code**
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
forces [callable](tablet-3-variables#callable)
context, alias to **[&()](#ampersand-context-op)**

<a id="code-adverb"/>
**:code**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
quasi quoting, the commented will be compiles and the AST will
be returned as result, see also: **[quasi](#quasi)**

<a id="codes"/>
**codes** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*«string mmethod»* &mdash;
number of *[unicode](appendix-g-glossary.html#unicode)*
*[codepoints](appendix-g-glossary.html#codepoints) of a string in a
language-independent way &mdash;
see also: [**bytes*](#bytes), [**chars**](#chars), [**graphs**](#graphs)

<a id="codes-modifier"/>
**:codes**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching on codepoint level (between codepoints), see also:
**[:bytes](#bytes-modifier)**,
**[chars](#chars-modifier)**,
**[:graphs](#graphs-modifier)**

<a id="comb"/>
**comb**
*«string method»* &mdash;
`$str.comb(/pattern/)` equals [`$str ~~ m:g/pattern/`](#m-op),
except it returns the list of findings, not a [match object](#match-var),
default pattern is [`rx/./`](#rx)

<a id="COMMENT-pod-var"/>
**@=COMMENT**
*[«special var»](appendix-b-grouped.html#pod-variables)* &mdash;
all the comment blocks in the file

<a id="Complex-type"/>
**Complex**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
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))

<a id="conj"/>
**conj**
([Complex](#Complex-type) \$c [--\>](#minus-minus-greater-signature) [Complex](#Complex-type))
«complex method» &mdash;
returns ($c.re - $c.im\i), the complex conjugate
see also: [**cis**](#cis), [**polar**](#polar), [**unpolar**](#unpolar)

<a id="conjugate"/>
**conjugate**
«complex method» &mdash;
convert [complex number](#complex-type) into real (**[Num](#Num-type)**) &mdash;
see also: [**abs**](#abs), [**sign**](#sign), [**truncate**](#truncate),
[**unpolar**](#unpolar), [**re**](#re), [**im**](#im)

<a id="constant"/>
**constant** *«var trait»* &mdash;
makes so declared var (*is constant*) a real constant

<a id="contend"/>
**contend** *«block modifier»* &mdash;
marks a block as atomic, concurrent proceses have to wait

<a id="continue"/>
**[continue](tablet-6-blocks.html#continue)** &mdash;
*(flow control)* - makes execution in a 'given' also try the
following 'when' clauses

<a id="continue-modifier"/>
**:continue**(<span class="you-provide">n</span>)
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching from nth (n is an int) position (counting from 0) and
then going to the right, short for
**[:c](#c-modifier)**

<a id="CONTROL-phaser"/>
**CONTROL**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block to catch control
**[Exception](#Exception-type)**
(like **[next](#next)** / **[last](#last)** / **[return](#return)** etc),
before **[LEAVE](#LEAVE-phaser)**

<a id="Cool-type"/>
**Cool**
*[«undefined value type»](appendix-b-grouped.html#undefined-types)* &mdash;
Perl 6 Convenient [OO](appendix-g-glossary.html#OOP) Loopbacks,

<a id="copy"/><a id="copy-parameter-trait"/>
**copy**
*[«parameter trait»](appendix-b-grouped.html#parameter-traits)* &mdash;
read-writable copy of the original argument ("pass-by-value")

<a id="cos"/><a id="cos-op"/>
**cos**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
cosine, trigonometric function, takes angle in radians; see also
**[to-radians](#to-radians)**,
**[sin](#sin)**, **[tan](#tan)**

<a id="count"/>
**count** *«routine method»* &mdash;
returns how many parameters this
*[routine](appendix-g-glossary.html#routine)* takes (including optional),
**[.arity](#arity)** counts just the required

<a id="cross"/>
**cross** *«list method»* &mdash;
alias to **[X operator](#X-op)** &mdash;
example: `@a X @b = (@a; @b).cross`

<a id="crosswith"/>
**crosswith** *«list method»* &mdash;
metaoperator that seeks every combination of one element of one list with an
element of a second list and applies then an [infix](#infix-category) operator
to that pair, returns a list the results,
alias method to **[X metaoperator](#X-metaop)** &mdash;
example: *`@a X~ @b`* equals *`(@a; @b).crosswith(&[~])`* equals
`(@a; @b).cross.lol.map { .reduce(&[~]) }`

<a id="CWD-global-var"/>
**$\*CWD**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
current working directory as **[Str](#Str-type)**



# [D](#nav-top)

<a id="d-test"/>
**:d**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
check if file is a directory

<a id="backslash-D"/>
**\\D**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
a single nondigit character

<a id="backslash-d"/>
**\\d**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
a single digit character, alias to [**\<digit\>**](#digit-subrule)

<a id="data-pod-var"/>
**\$=data**
*[«special var»](appendix-b-grouped.html#pod-variables)* &mdash;
handle for the data block (=begin data ... =end data),
use *$=data.lines* to *[iterate](appendix-g-glossary.html#interation)*
over the lines of it

<a id="decode"/>
**[decode](tablet-5-io.html#read)**
*«Buf method»* &mdash;
transforms raw binary UTF
(**[Buf](#Buf-type)**) into readable UTF Text
(**[Str](#Str-type)**)

<a id="default"/>
**[default](tablet-6-blocks.html#default)**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
following block will be run if no **[when](#when)**
clause in surrounding block matched

<a id="defer"/>
**defer** * *«block modifier»* &mdash;

<a id="defined"/>
**defined** &mdash; scalar method tests whether a value has been assigned
to a variable

<a id="delete"/><a id="delete-array"/>
**delete**
*[«array method»](tablet-3-variables#array-methods)* &mdash;
removes all values of which indices are passed

<a id="delete-hash"/>
**delete**
*[«hash method»](tablet-3-variables#hash-methods)* &mdash;
removes all [pairs](#pair) of which keys are passed

<a id="denominator"/>
**denominator**
( [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*[«rat method»](tablet-2-basic-syntax.html#rational-number)* &mdash;
returns the denominator of a rational number
(value type **[Rat](#Rat-type)** and **[FatRat](#FatRat-type)**),
opposite of [**numerator**](#numerator) &mdash;
see also: [**nude**](#nude)


<a id="die"/>
**die** &mdash;
throws a fatal **[Exception](#exception-type)**, the default
exception handler **[print](#print)**'s each element
of the list to **[$\*ERR](#ERR-global-var)**

<a id="digit-subrule"/>
**\<digit\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
single (decimal) digit char, alias to **[\\d](#backslash-d)**

<a id="dir"/>
**[dir](tablet-5-io.html#dir)** &mdash;
returns all files of a given directory, excluding . and .. by
default

<a id="DISTRO-global-var"/>
**\$\*DISTRO**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
running OS distribution, you might want to use `$*DISTRO.name`,
see also: **[\$\*KERNEL](#KERNEL-global-var)** and
**[\$\*VM](#VM-global-var)**

<a id="DISTRO-compiler-var"/>
**\$\?DISTRO**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
[OS](#kernel-compiler-var) distribution the
program was compiled for, see also:
**[\$?KERNEL](#kernel-compiler-var)** and
**[\$\*VM](#vm-compiler-var)**

<a id="div"/>
**[div](operators.html)** &mdash; integer division

<a id="do"/>
**[do](tablet-6-blocks.html#do)** &mdash;
executes a *[block](appendix-g-glossary.html#block)*, the "do once" loop

<a id="does"/>
**does** &mdash;
checks if an objekt inherits a **[role](#role)** (only parameter)

<a id="dotty-category"/>
**dotty**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;

<a id="double-adverb"/>
**[:double](tablet-2-basic-syntax.html#double-quotes)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
*double quoting*, **q** with interpolation of variables, alias
to **["..."](#double-quotes)**, **[qq
/.../](#qq-op)** and `Q :s :a :h :f :c :b /.../`,
long for **[:qq](#qq-adverb)**

<a id="Duration-type"/>
**Duration** 
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
The difference between two Instants

<a id="dynamic"/><a id="dynamic-parameter-trait"/>
**dynamic**
*[«parameter trait»](appendix-b-grouped.html#parameter-traits)* &mdash;
parameter is an "environmental" variable, a lexical in the
dynamic *[scope](appendix-g-glossary.html#scope)*



# [E](#nav-top)

<a id="e-test"/>
**:e**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
tests if file exists

<a id="backslash-E"/>
**\\E**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
anything but an escape character

<a id="backslash-e"/>
**\\e**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
escape character

<a id="each"/>
**each** &mdash; variant of all() that promises to do things in order, is
Positional/Iterable

<a id="eager"/>
**eager** &mdash;
forces eager *[evaluation](appendix-g-glossary.html#evaluation)*
(compute all values now), default for scalars - not for lists,
opposite of **[lazy](#lazy)**

<a id="EGID-global-var"/>
**\$\*EGID**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
effective global ID of the running process
(**[\$\*PID](#PID-global-var)**) owner,
in Perl 5: *@\)* and *\$EGID*

<a id="elems"/><a id="elems-aray"/>
**elems**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
number of elements (values), see also:
**[end](#end)**

<a id="elems-hash"/>
**elems**
*[«hash op & method»](tablet-3-variables#hash-methods)* &mdash;
number of pairs

<a id="else"/>
**[else](tablet-6-blocks.html#else)**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
introduces the alternative block after an
**[if](#if)** or **[elsif](#elsif)**
that is executed, when conditions of all alternatives resulted
in **[False](#False)** &mdash; see also: **[default](#default)**

<a id="else"/>
**[elsif](tablet-6-blocks.html#elsif)**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
alternative **[if](#if)** clause

<a id="ENC-compiler-var"/>
**\$\?ENC**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
current *[encoding](appendix-g-glossary.html#encoding)*

<a id="encode"/>
**[encode](tablet-5-io.html#read)**
*«Buf method»* &mdash;
transforms readable UTF Text (**[Str](#Str-type)**)
into raw binary UTF (**[Buf](#Buf-type)**)

<a id="END-phaser"/>
**END**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block, executed at run time,
*[ALAP](appendix-g-glossary.html#ALAP)*, only ever runs once

<a id="end"/>
**end**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
last index of that list, see also: **[elems](#elems)**

<a id="ENTER-phaser"/>
**ENTER**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block or statement, executed at
every block entry time, repeats on [loop](appendix-b-grouped.html#loops) blocks

<a id="Enum-type"/>
**Enum**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
an immutable **[Pair](#Pair-type)**

<a id="enum"/>
**enum** &mdash; 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) &mdash;
example: `%hash = enum <<:Mon(1) Tue Wed Thu Fri Sat Sun>>;`

<a id="EnumMap-type"/>
**EnumMap**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
A mapping of Enums with no duplicate keys

<a id="ENV-global-var"/>
**%\*ENV**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
environment variables (of the shell), in Perl 5: *%ENV*

<a id="eq"/><a id="eq-op"/>
**eq**
*[«comparison op»](tablet-4-operators.html#string-comparison)* &mdash;
[infix](#infix-category) operator,
proves equality in forced [*string context*](tablet-4-operators.html#string-context)
as does [**==**](#equal-equal-op) in 
[*numeric context*](appendix-g-glossary.html#numeric-context)

<a id="equiv"/>
**equiv**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
specifies the [precedence of an
operator](appendix-b-grouped.html#table-of-precedence)
same as an existing operator

<a id="eqv"/>
**eqv** *«comparison op»* &mdash;
[infix](#infix-category)
operator, compares the dynamic state of objects and values, in
contrast with static [**===**](#equal-equal-equal)

<a id="err"/><a id="err-op"/>
**err** *[«logical op»](tablet-4-operators.html#logical-selection)* &mdash;
short circuit defined or, returns the first defined value from
the left, low precedence version of **[//](#defined-or)** &mdash;
see also: [**or**](#or), [**xor**](#xor)

<a id="ERR-global-var"/>
**\$\*ERR**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
[*file handle*](IO-type) for the standard error output (command line mostly),
in Perl 5: *STDERR*

<a id="EUID-global-var"/>
**\$\*EUID**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
effective user ID of the running process (**[\$\*PID](#PID-global-var)**) owner,
in Perl 5: *@\>* and *$EUID* 

<a id="eval"/>
**eval** &mdash;
just *[compiles](#compilation)* a [string](#Str-type) and runs it,
returns a result and maybe error message in
**[$!](#exclamation-mark-var)** but does not catch
**[Exceptions](#Exception-type)**, second optional parameter defines a
parser **[grammar](#Grammar-type)** which should understand the string

<a id="evalfile"/>
**evalfile** &mdash;
**[eval](#eval)** a file like *do* did in Perl 5,
with optional second parameter, which is a
*[grammar](#Grammar-type)* that can parse that file

<a id="ex-modifier"/>
**:ex**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching at all positions as long as it findes something (with
backtracking), short for
**[:exhaustive](#exhaustive-modifier)**

<a id="Exception-type"/>
**Exception**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
Perl exception, errors or abnormal events interfering with
normal execution, which Perl 6 can both generate and handle

<a id="exec-adverb"/>
**:exec**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
quoted [string](#Str) will be *[evaluated](appendix-g-glossary.html#evaluation)*
as Perl code (like **[eval](#eval)**) replaced with its result, alias to
**Q :x** and **[qx/.../](#qx-op)**

<a id="EXECUTABLE-NAME-global-var"/>
**\$\*EXECUTABLE\_NAME**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
name of the main scripts file name, in Perl 5: *$0* 

<a id="exhaustive-modifier"/>
**:exhaustive**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching at all positions as long as it findes something (with
backtracking), long for **[:ex](#ex-modifier)**

<a id="exists"/>
**exists** &mdash; checks for existence of a variable,
array or hash element, also scalar method

<a id="exit"/>
**exit** *«flow control»* &mdash;
stops all program execution, and returns
Int $status (first parameter) to the calling environment

<a id="exp"/><a id="exp-op"/>
**exp** ([Num](#Num-type) $base, [Num](#Num-type) $exp?
         [--\>](#minus-minus-greater-signature) [Num](#Num-type)) &mdash;
exponentiate, alias method to: $base **[\*\*](#asterisk-asterisk-op)** $exp
(defaults to *[e](appendix-g-glossary.html#e)*)

<a id="export"/><a id="export-rouine-trait"/>
**export**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
this *[routine](appendix-g-glossary.html#routine)* will be exported by
the current [**module**](#module) by default



# [F](#nav-top)

<a id="f-test"/>
**:f**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
file is a plain file (no socket or dir, ...etc.)

<a id="f-adverb"/>
**:f**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
demands evaluation of functions (subs and methods), that start
with the **[&-sigil](#ampersand-sigil)** and
replacing them with the result, long form of
**[:function](#function-adverb)**, included in 
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="backslash-F"/>
**\\F**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
any character but form feed

<a id="backslash-f"/>
**\\f**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
form feed character (`\u000C`), as in Perl 5

<a id="fail"/>
**fail** &mdash;
causes the [routine](appendix-g-glossary.html#routine) to return an unthrown
**[Exception](#Exception-type)**, if *use fatal;* is
in effect where the *[routine](appendix-g-glossary.html#routine)* was called from,
it throws the exception

<a id="Failure"/><a id="Failure-type"/>
**Failure**
*[«undefined value type»](appendix-b-grouped.html#undefined-types)* &mdash;
data type object for an error, thrown by an unhandled
**[Exception](#Exception-type)**

<a id="False"/>
**False** &mdash;
*[boolean](#Bool-type)* value aka
Bool::False, 0 in [*numeric context*](appendix-g-glossary.html#numeric-context),
'' (empty) in *[string context](appendix-g-glossary.html#string-context)*,
opposite of **[True](#True)**

<a id="FatRat-type"/>
**FatRat**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
Perl rational (unlimited precision in both parts)

<a id="fc"/>
**fc** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«string method»* &mdash;
return a copy of a string where the *[Unicode](appendix-g-glossary.html#unicode)*
"fold case" operation is done upon,
suitable for doing caseless string comparisons &mdash;
see also: [**lc**](#lc) and [**uc**](#uc)


<a id="ff"/><a id="ff-op"/>
**[ff](tablet-4-operators.html#flipflop)**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
tests **[$\_](#context-var)**
against two values, flip flop operator in the style of awk, can
test the right operand and become **[False](#False)**
on the same evaluation it became **[True](#True)**
in Perl 5: *..* in [scalar context](appendix-g-glossary.html#scalar-context)

<a id="fff"/><a id="fff-op"/>
**[fff](tablet-4-operators.html#flipflop)**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
flip flop operator in the style of sed,
tests **[\$\_](#context-var)** against two values,
after return value became **[True](#True)**
(**[$\_](#context-op)** is larger then left value),
right side will be tested during next loop
*[iteration](appendix-g-glossary.html#interation)*,
can be combined with [**^**](#caret-range) to exclude borders
in Perl 5: *...* in *[scalar context](appendix-g-glossary.html#scalar-contex)*

<a id="FILE-compiler-var"/>
**$?FILE**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
current filename of source file

<a id="file"/>
**file**
*[«callframe method»](appendix-b-grouped.html#callframe-methods)* &mdash;

<a id="FIRST-phaser"/>
**FIRST**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block or statement, executed at
[loop](appendix-b-grouped.html#loops) initialization time,
before any **[ENTER](#ENTER-phaser)**

<a id="first"/>
**first**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
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 [**`$_`**](#context-var) or `$^a`),
works like [**grep**](#grep) &mdash;
example : `first {$_ %% 2}, 1..5 ; # returns 2`

<a id="flat"/>
**flat**()
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
forces flat [*list context*](appendix-g-glossary.html#list-context),
opposite of **[lol()](#lol)** &mdash;
example: `([2,3],[4,5]).flat` or `flat([2,3],[4,5])` results in: `[2..5]`

<a id="flip"/>
**flip** *«string method»* &mdash; reverses order of characters in
[string](#Str-type) , see also:
**[reverse](#reverse)** and
**[invert](#invert)**

<a id="floor"/>
**floor**
([Num](#Num-type) $x [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*«num method»* &mdash;
highest integer not greater than $x, rounds down no the next whole number &mdash;
example: `floor 5.4` returns `5` `floor -5.4` returns `-6` &mdash;
see also: [**ceiling**](#ceiling), [**round**](#round), [**truncate**](#truncate)

<a id="fmt"/>
**[fmt](tablet-2-basic-syntax.html#fmt)**
*«formater»* &mdash;
variable method for simple
**[printf](#printf)** - like formating, takes a
format specifier and returns a [string](#Str-type) ,
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);

<a id="for"/>
**[for](tablet-6-blocks.html#for)**
*[«block modifier»](appendix-b-grouped.html#loops)* &mdash;
loop that only iterates over the following list and sets
**[$\_](#context-var)** for each
*[iteration](appendix-g-glossary.html#interation)* (contextualizer), see
also: **[given](#given)**

<a id="fork"/>
**[fork](tablet-5-io.html#processes)** &mdash;
creates a copy of the current process and returns in the
original process a Proc object of the child 
(0 in [*num context*](appendix-g-glossary.html#numeric-context))
and in the child a proc object of the original
(process ID in [*numeric context*](appendix-g-glossary.html#numeric-context))

<a id="from-radians"/>
**from-radians** &mdash;
convert from radians to $base (second parameter),
opposite of **[to-radians](#to-radians)**

<a id="function-adverb"/>
**[:function](tablet-2-basic-syntax.html#interpolation)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
demands evaluation of functions (subs and methods), that start
with the **[&-sigil](#ampersand-sigil)** and
replacing them with the result, long form of
**[:f](#f-adverb)** , included in
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**



# [G](#nav-top)

<a id="g-test"/>
**:g**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
report if file has setgid bit set

<a id="g-modifier"/>
**:g**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching for any finding (not just the first), short for
**[:global](#global-modifier)**

<a id="pipe-g"/>
**\<|g\>**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
grapheme boundary, zero width space between two 
*[unicode](appendix-g-glossary.html#unicode)* graphemes,
opposite is **\<!|g\>**&mdash;
see also: **[\<|c\>](#pipe-c)** and **[\<|w\>](#pipe-w)**

<a id="gcd"/>
**gcd**
*[«numeric infix op»](tablet-4-operators.html#numeric-context)* &mdash;
greatest common divisor (see also: **[lcm](#lcm)**)

<a id="gather"/>
**[gather](tablet-6-blocks.html#gather-and-take)**
*«block modifier»* &mdash;
performs the following block once, returns a
list of all values passed by **[take](#take)**

<a id="ge"/><a id="ge-op"/>
**ge**
*[«infix string comparison»](tablet-4-operators.html#string-comparison)* &mdash;
greater than or equal, see also **[gt](#gt)** and
**[le](#le)**

<a id="get"/>
**[get](tablet-5-io.html#get)**
*«handle method»* &mdash;
returns a line ([*item context*](appendix-g-glossary.html#item-context)) or all lines
([*list context*](appendix-g-glossary.html#list-context)) 
from that input stream like a file or [command line](tablet-5-io.html#command-line)

<a id="getc"/>
**[getc](tablet-5-io.html#getc)**
*«handle method»* &mdash;
reads one character from a file via [*file handle*](IO-type)

<a id="getlogin"/>
**getlogin** &mdash;
returns the username of the account running the
program, maybe less secure as **[getpwuid](#getpwuid)**

<a id="gethost"/>
**gethost** &mdash;
establish a connection to a net host and retrieve information

<a id="GID-global-var"/>
**\$\*GID**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash; 
real global ID of the running process
(**[\$\*PID](#PID-global-var)**) owner, in Perl 5: *@(* and *$GID*

<a id="gist"/>
**gist**
( [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«formater»* &mdash;
generates a string with the essential content of that object
for human consumption (like in error messages),
**[Mu](#Mu-type)** will foreward to **[.perl](#perl)**

<a id="given"/>
**[given](tablet-6-blocks.html#given)**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
part of a case-like construct, puts the following value into the
[context variable](#context-var) (thatswhy called
contextualizer) for **[when](#when)** clauses, see
also **[for](#for)**

<a id="global-modifier"/>
**:global**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching for any finding (not just the first), long for
**[:g](#g-modifier)**

<a id="goto"/>
**[goto](tablet-6-blocks.html#goto)**
*[«flow control»](appendix-b-grouped.html#jump-commands)* &mdash;
continue execution on a defined label (with "name:")

<a id="grab"/>
**grab**
*[«hash method»](tablet-3-variables#hash-methods)* &mdash;
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](#pick)**
ans **[roll](#roll)**

<a id="grabpair"/>
**grabpair**
*[«hash method»](tablet-3-variables#hash-methods)* &mdash;
random selection <span class="you-provide">n</span> (only parameter) of hash
**[pairs](#pair)**, (each pair only once), see also
**[pick](#pick)** ans **[roll](#roll)**

<a id="grammar"/>
**grammar**
*«block modifier»* &mdash;
special kind of **[class](#class)**
with methods like **[regex](#regex)**, **[token](#token)**, **[rule](#rule)**
that execute [*regex*](appendix-g-glossary.html#regex) and are named subpatterns,
produces a [match object](#match-var), the name is ment like in
"Parsing Expression Grammar" (PEG)

<a id="GRAMMAR-compiler-var"/>
**\$?GRAMMAR**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
[grammar](#grammar) of the currently used [*slang*](appendix-g-glossary.html#slang)
(mostly **[$\~MAIN](#MAIN-slang-var)**)

<a id="graph-subrule"/>
**\<graph\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
a "graphical" character, calles [*grapheme*](#grapheme)

<a id="graphs"/>
**graphs** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*«string mmethod»* &mdash;
number of *[unicode](appendix-g-glossary.html#unicode)*
*[graphemes](appendix-g-glossary.html#graphemes)* of a string,
in a language-independent way &mdash;
see also: [**bytes**](#bytes), [**chars**](#chars), [**codes**](#codes)

<a id="graphs-modifier"/>
**:graphs**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching on the level of language-independent graphemes, see
also: see also: **[:bytes](#bytes-modifier)**,
**[chars](#chars-modifier)**,
**[:codes](#code-modifier)**

<a id="grep"/>
**grep**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
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 [**`$_`**](#context-var) or `$^a`) &mdash;
see also **[first](#first)** &mdash;
example : `grep {$_ %% 2}, 1..5;` returns `2, 4`

<a id="gt"/><a id="gt-op"/>
**gt**
*[«string comparison»](tablet-4-operators.html#string-comparison)* &mdash;
[infix](#infix-category) operator, greater than
or equal, **[True](#True)** if alphabetically
ordered the right comes before the left &mdash;
see also: **[lt](#lt)**, **[leg](#leg)** and [**<**](#lower-op)



# [H](#nav-top)

<a id="h-test"/>
**:h**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
demands evaluation of **[hash](#hash)**
variables that start with the
**[%-sigil](#percent-sigil)**, long form of
**[:hash](#hash-adverb)**, included in
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="backslash-H"/>
**\\H**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
anything but horizontal whitespace char

<a id="backslash-h"/>
**\\h**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
a horizontal whitespace char,
build together with [vertical whitespace](#backslash-v) the sum of all
[whitespace](#backslash-s) character

<a id="handles"/>
**handles** &mdash;
[delegates](appendix-g-glossary.html#delegation) execution of a method
to a method of an attribute

<a id="HardRoutine-type"/>
**HardRoutine**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
a *[routine](appendix-g-glossary.html#routine)* that is committed to not changing

<a id="has"/>
**has**
*[«scope declarator»](appendix-b-grouped.html#scope-declarator)* &mdash;
introduces attribute names, see also
**[class](#class)**

<a id="Hash-type"/>
**Hash**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
Perl hash, a two column table of **[Scalar](#Scalar-type)**,
values in one column are keys to refer to the values in the other column,
can be also seen as a **[Set](#Set-type)** of **[Pairs](#Pair-type)**

<a id="hash"/><a id="hash-op"/>
**hash**
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
enforces [*hash context*](appendix-g-glossary.html#hash-context),
alias to **[%()](#percent-op)**

<a id="hash-adverb"/>
**[:hash](tablet-2-basic-syntax.html#interpolation)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
demands evaluation of hash variables that start with the
**[%-sigil](#percent-sigil)**, long form of
**[:h](#h-adverb)**, included in
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="heredoc-adverb"/>
**[:heredoc](tablet-2-basic-syntax.html#heredocs)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
defines end marker for the following heredoc, **:heredoc** is
equal to **[:to](#to-adverb)**

<a id="HOW-introspection"/>
**HOW**
*[«introspection method»](appendix-b-grouped.html#object-introspection)* &mdash;
get an instance the objects metaclass, its "Higher Order Workings"

<a id="hyper"/>
**hyper** &mdash;
forces none-lazy [*list context*](appendix-g-glossary.html#list-context),
that ignores the order of results (allows parallel computing)



# [I](#nav-top)

<a id="i-modifier"/>
**:i**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
uppercase and lowercase variants of a letter are taken as the
same letter, short for **[:ignorecase](#ignorecase-modifier)**
(same as in Perl 5)

<a id="ident-subrule"/>
**\<ident\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
an identifier

<a id="if"/>
**[if](tablet-6-blocks.html#if)**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
if the following expression *[evals](#evaluation)*
to **[True](#True)**, the block after that will be
run, opposite of **[unless](#unless)**, can also be
written at the end of an expression

<a id="ignorecase-modifier"/>
**:ignorecase**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
uppercase and lowercase variants of a letter are taken as the
same letter, long for **[:i](#i-modifier)** (as in Perl 5)

<a id="ignoremark-modifier"/>
**:ignoremark**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
comparing base characters (*[unicode](appendix-g-glossary.html#unicode)*
non-mark characters) while ignoring any trailing mark characters,
long for **[:m](#m-modifier)**

<a id="ii-modifier"/>
**:ii**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
only for substitutions, replacing with chars that have the same
case pattern as the replaced, short for
**[:samecase](#samecase-modifier)**

<a id="im"/>
**im**
«complex method» &mdash;
imaginary part of a complex number &mdash;
see also: [**truncate**](#truncate), [**unpolar**](#unpolar), [**re**](#re)

<a id="import"/>
**[import](subroutines.html)** &mdash;
just import definitions from an already loaded module (see
**[use](#use)** and **[need](#need)**)

<a id="IN-global-var"/>
**\$\*IN**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
[*file handle*](IO-type) for the standard input (command line mostly), see also
**[$\*OUT](#OUT-global-var)**, in Perl 5: *STDIN*

<a id="INC-global-var"/>
**\@\*INC**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
include pathes (but not for standard library modules), in Perl 5: *@INC*

<a id="index"/>
**index** *«string method»* &mdash;
finds the first occurrence of a substring in a string
and returns the numerical position, opposite or **[rindex](#rindex)**

<a id="Inf"/>
**Inf** &mdash;
indicates infinity, useful to generate infinite lazy lists,
does in most [*context*](appendix-g-glossary.html#context) same as **[\*](#asterisk)**

<a id="infix-category"/>
**infix**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
namespace of symbols that stay between two statements,
that become their parameters &mdash;
example ([plus](#plus-op)): `$a + $b ` is same as `$a.&infix:<+>($b)`

<a id="infix-circumfix-meta-category"/>
**infix\_circumfix\_meta\_operator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace of
[metaoperator](appendix-g-glossary.html#metaoperator) that
[circumfix](#circumfix-category) other operator but
stay [infix](#infix-category) (between) two terms (mostly lists) &mdash;
example: ([arrows](#lower-lower-metaop)): `@a <<+<< @b`

<a id="infix-postfix-meta-category"/>
**infix\_postfix\_meta\_operator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace of [metaoperator](appendix-g-glossary.html#metaoperator)
that [postfix](#postfix-category) other operator but
stay [infix](#infix-category) (between) two terms &mdash;
example ([equal sign](#equal-metaop)): `$a += 5`

<a id="infix-prefix-meta-category"/>
**infix\_prefix\_meta\_operator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace of
[metaoperator](appendix-g-glossary.html#metaoperator) that
[prefix](#prefix-category) (precedes) other operator
but stay [infix](#infix-category) (between) two terms &mdash;
example ([exclamation mark](#exclamation-metaop)): `4 != 5`

<a id="INIT-phaser"/>
**INIT**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block or statement, executed at run
time, [ASAP](appendix-g-glossary.html#ASAP), only ever runs once

<a id="inline"/>
**inline** *[«callframe method»](appendix-b-grouped.html#callframe-methods)* &mdash;
**[False](#False)** if that block is called like a
*[routine](appendix-g-glossary.html#routine)*

<a id="Instant-type"/>
**Instant**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
a point on the continuous atomic timeline

<a id="Int-type"/>
**Int**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
Perl integer, objext type to hold whole number like 1, 2 or 6000,
allows **[Inf](#Inf)** / NaN, arbitrary precision,
use it as method to convert into a **Int** like the Perl 5 *int*

**invert**
*[«hash op & method»](tablet-3-variables#hash-methods)* &mdash;
inverts the key =\> value relation of a pair or a series of
pairs (hash), returning a **[Pair](#pair)**
**[list](#list)**, see also
**[reverse](#reverse)** and
**[flip](#flip)**

<a id="IO-type"/>
**IO**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
Perl filehandle

<a id="is"/>
**is** &mdash;
bind a *[trait](appendix-g-glossary.html#trait)* to a variable

<a id="item"/><a id="item-op"/>
**item()**
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
forces [scalar context](appendix-g-glossary.html#scalar-context),
alias to **[$()](#dollar-op)**

<a id="Iterator-type"/>
**Iterator**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
Perl list



# [J](#nav-top)

<a id="join"/>
**join**
*[«array method»](tablet-3-variables#array-methods)* &mdash;
concatenates list elements into a string, optionally inserting
another string between the elements &mdash;
example: `join("-", 1..5) # returns '1-2-3-4-5'` alternative syntax: `(1..5).join("-")`



# [K](#nav-top)

<a id="k-test"/>
**:k**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
report if file has sticky bit set

<a id="KEEP-phaser"/>
**KEEP**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block, executed at every successful
block exit, part of **[LEAVE](#LEAVE-phaser)** queue

<a id="keepall-modifier"/>
**:keepall**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
forces subrules to memorize everything (even comments)

<a id="KERNEL-global-var"/>
**\$\*KERNEL**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
(core or type of the) running operating system, use
*`$*KERNEL.name`* instead of Perl 5s *$OSNAME* &mdash; see also:
**[\$\*DISTRO](#DISTRO-global-var)** and
**[\$\*VM](#VM-global-var)**

<a id="KERNEL-compiler-var"/>
**\$?KERNEL**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash; 
kernel (core operating system) the program was compiled for,
might want to use use `$?KERNEL.name` &mdash; see also:
**[\$?DISTRO](#distro-compiler-var)** and
**[\$?VM](#vm-compiler-var)**

<a id="key"/>
**key**
*[«pair method»](tablet-3-variables#pair)* &mdash;
gives the key part of a pair, opposite of
**[value](#value)**

<a id="KeyBag-type"/>
**KeyBag**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
KeyHash of UInt, does **[Bag](#Bag-type)** in
[*list context*](appendix-g-glossary.html#list-context)

<a id="KeySet-type"/>
**KeySet** *[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
KeyHash of **[Bool](#Bool-type)** (does **[Set](#Set-type)**
in [*list context*](appendix-g-glossary.html#list-context)

<a id="keys-array"/>
**keys** *[«array op & method»](tablet-3-variables#array-methods)* &mdash;
returns the list of array indexes

<a id="keys"/><a id="keys-hash"/>
**keys** *[«hash method»](tablet-3-variables#hash-methods)* &mdash;
returns list of hash keys

<a id="kill"/>
**[kill](tablet-5-io.html#processes)** &mdash;
sends the given $signal to the process(es) given and returns a
boolean value indicating success (**[True](#True)**)

<a id="kv"/>
**kv**
*[«hash method»](tablet-3-variables#hash-methods)* &mdash;
returns list of key-value pairs



# [L](#nav-top)

<a id="l-test"/>
**:l**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
file is a symbolic link

<a id="backslash-L"/>
**\\L\[**<span class="you-provide">n</span>**\]**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
everything within the brackets is lowercase

<a id="LANG-global-var"/>
**$\*LANG**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
LANG variable from **[%\*ENV](#ENV-global-var)**
that defines what human language is used

<a id="LANG-compiler-var"/>
**%?LANG**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
current set of interwoven languages

<a id="LAST-phaser"/>
**LAST**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block, executed at [loop](appendix-b-grouped.html#loops)
termination time, after any **[LEAVE](#LEAVE-phaser)**

<a id="last"/>
**last**
*[«flow control»](appendix-b-grouped.html#jump-commands)* &mdash;
exit the current looping block

<a id="last-array"/>
**last**
*[«array method»](tablet-3-variables#array-methods)* &mdash;
number of final element

<a id="lazy"/>
**lazy** &mdash;
forces lazy evaluation (calculate values as late as possible),
default for lists - not scalars

<a id="lc"/>
**lc** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«string method»* &mdash;
return a copy of a string where all characters are lowercase &mdash;
see also: [**fc**](#fc) and [**uc**](#uc)

<a id="lcfirst"/>
**lcfirst** *«string op & method»* &mdash;
make first character of a string lowercase

<a id="lcm"/><a id="lcm-op"/>
**lcm**
*[«numeric infix op»](tablet-4-operators.html#numeric-context)* &mdash;
least common multiple &mdash;
example: `4 lcm 6` returns: `12` &mdash;
see also: **[gcd](#gcd)**

<a id="le"/>
**le**
*[«string comparison»](tablet-4-operators.html#string-comparison)* &mdash;
[infix](#infix-category) operator, result is
**[True](#True)** if left side is lower than or
equal than the right, see also: **[lt](#lt)**,
**[gt](#gt)** and **[ge](#ge)**

<a id="LEAVE-phaser"/>
**LEAVE**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block, executed at every block exit
time

<a id="leave"/>
**[leave](tablet-6-blocks.html#leave)**
*[«flow control»](appendix-b-grouped.html#jump-commands)* &mdash;
exit the current block with a return value

<a id="leg"/><a id="leg-op"/>
**leg**
*[«string comparison»](tablet-4-operators.html#string-comparison)* &mdash;
[infix](#infix-category) comparison operator that sees its operands in
*[string context](appendix-g-glossary.html#string-context)*,
leg stands for lower/equal/greater and it works otherwise like
[**cmp**](#cmp) (general form) or 
[**\<=\>**](#spaceship-op) ([numerical context](#numerical-context),
in Perl 5: *cmp*

<a id="let"/>
**let** &mdash;
changes value of a variable temporary, it will be set back
if the current block exits unsuccessfully

<a id="LINE-compiler-var"/>
**$?LINE**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
current line number

<a id="lines"/>
**[lines](basic-syntax.html)**
*«string & iomethod»* &mdash;
returns a chomped list of lines
(chunks of character separated by **[\\n](#backslash-n)**)
containing a string - example: `$str.lines($limit)` equals
[`$str.comb( / ^^ \N* /, $limit )`](#comb),
works also on [*file handles*](IO-type) &mdash;
see also: [**words**](#words)

<a id="list"/>
**list**()
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
almost a no-op, just makes sure that $item (first parameter) can
be iterated, alias to **[@()](#at-op)**, see also
**[flat](#flat)** and **[lol](#lol)**

<a id="log"/>
**[log](operators.html)** ([Num](#Num-type) $x, [Num](#Num-type) $base?) &mdash;
logarithm of $x to the $base
(default is *[e](appendix-g-glossary.html#e)*, together also known as *ln*)

<a id="log10"/>
**[log10](operators.html)** &mdash;
logarithm to the base of 10,
also known as *log* on calculators and *lg* in math classes

<a id="LoL-type"/>
**Lol**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
arguments in a semicolon list, name is short fpr "List of Lists"

<a id="lol"/>
**lol**()
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
forces list of [*list context*](appendix-g-glossary.html#list-context) on a value,
meaning a list which values are not contextualized further
(can be lists themthelves), opposite of **[flat](#flat)**

<a id="loop"/>
**[loop](tablet-6-blocks.html#loop)**
*[«block modifier»](appendix-b-grouped.html#loops)* &mdash;
general loop, can serve as enless loop without following term of
C-style loop - example: *loop my $b=1; $b++; $b<5 {...}*

<a id="looser"/><a id="looser-routine-trait"/>
**looser**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
specifies the
[precedence of an operator](appendix-b-grouped.html#table-of-precedence)
lower than an existing operator

<a id="lower-subrule"/>
**\<lower\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
a single lowercase character

<a id="lt"/>
**lt**
*[«string comparison»](tablet-4-operators.html#string-comparison)* &mdash;
[infix](#infix-category) operator, lower than,
**[True](#True)** if alphabetically ordered the left comes before the right &mdash;
see also: **[gt](#gt)**, **[leg](#leg)** and [**\>**](#greater-op)



# [M](#nav-top)

<a id="m-op"/>
**[m/ /](tablet-9-regexes.html#matching)**
*[«regex quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
perform a regex based search in place (m stands for *match* ),
similar to **[match](#match)**-method

<a id="m-modifier"/>
**:m** *[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
comparing base characters (*[unicode](appendix-g-glossary.html#unicode)*
non-mark characters) while ignoring any trailing mark characters,
short for **[:ignoremark](#ignoremark-modifier)**

<a id="Macro-type"/>
**Macro**
*[«mutable type»](appendix-b-grouped.html#mutable-types)*
[compile-time](appendix-g-glossary.html#compile-time)
[subroutine](appendix-g-glossary.html#subroutine),
that can alter the program itself

<a id="macro"/>
**macro**
*[«routine type»](appendix-b-grouped.html#routine-types)* &mdash;
define a *[routine](appendix-g-glossary.html#routine)* to alter source
code at *[compile time](appendix-g-glossary.html#compile-time)*

<a id="MAIN-slang-var"/>
**$\~MAIN**
*[«special var»](appendix-b-grouped.html#slang-variables)* &mdash;
current [grammar](#grammar) of main language,
tells the parser the rules of parsing Perl

<a id="map"/>
**map**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
take a list, perform a block on each member, return a list of
the results &mdash; example: `say map { chr $_ }, 66..69` *(is "B C D E")*
or `say map { chr $_ }, 66..69`

<a id="Match-type"/>
**Match**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
Perl match object, usually produced by applying a pattern of
*[regular expression](#regex)* to a
string

<a id="match"/>
**match** *«string method»* &mdash;
method alias to **[m/.../](#m-op)** operator,
`$str.match( /`<span class="you-provide">`p`</span>`/ )`
equals `$str ~~ m/`<span class="you-provide">`p`</span>`/;`,
returns a match object that end up also in **[$/](#match-var)** &mdash;
see also **[comb](#comb)**

<a id="max"/><a id="max-op"/>
**max**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
returns the [numerically](appendix-g-glossary.html#numeric-context)
largest value from a given list &mdash;
see also: **[min](#min-op)** and **[minmax](#minmax-op)**

<a id="maybe"/>
**maybe** *«block modifier»* &mdash;

<a id="metachar-category"/>
**metachar**
*[«grammatical category»](appendix-b-grouped.html#regex)* &mdash;
internal namespace for [*regex*](appendix-g-glossary.html#regex)
[*metacharacters*](appendix-b-grouped.html#regex-metacharacter)
like [**.**](#dot-metachar)

<a id="Method-type"/>
**Method**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
type of Perl method object

<a id="method"/>
**method**
*[«routine type»](appendix-b-grouped.html#routine-types)* &mdash;
defines a method (inheritable *[routine](appendix-g-glossary.html#routine)*)
in a **[class](#class)**

<a id="min"/><a id="min-op"/>
**min**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
returns the [numerically](appendix-g-glossary.html#numeric-context)
smallest value from a given list &mdash;
see also: **[max](#max-op)** and **[minmax](#minmax-op)** 

<a id="minmax"/><a id="minmax-op"/>
**minmax**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
returns the [numerically](appendix-g-glossary.html#numeric-context)
highest and lowest values from a list, as a 2 item list &mdash;
see also: **[min](#min-op)** and **[max](#max-op)**

<a id="mkdir"/>
**[mkdir](tablet-5-io.html#mkdir)** &mdash;
creates a directory with given name

<a id="mm-modifier"/>
**:mm**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
substitute with chars that has same mark/accent pattern as the
matched string, short for
**[:samemark](#samemark-modifier)**

<a id="mod"/>
**mod** *«numeric op»* &mdash;
integer modulo operator; wordy alias to
**[%](#percent)** &mdash; example: `5 mod 4 = 1;`

<a id="mod-internal-category"/>
**mod\_internal**
*[«grammatical category»](appendix-b-grouped.html#regex)* &mdash;
internal namespace for [*regex modifier*](appendix-b-grouped.html#regex-modifier)
like [**:P5**](#P5-modifier)

<a id="module"/>
**module** *«block modifier»* &mdash;
introduces a module name, a package that performs special actions on loading

<a id="MODULE-compiler-var"/>
**&?MODULE**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
reference to the current module

<a id="ms"/><a id="ms-op"/>
**[ms/ /](tablet-9-regexes.html#matching)**
*[«regex quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
perform a regex based search in place, spaces are just subrule
separators, alias to **m:s/.../** or **m**
**[:sigspace](#sigspace-modifier)** **/.../**

<a id="Mu-type"/>
**Mu**
*[«undefined value type»](appendix-b-grouped.html#undefined-types)* &mdash;
most (generic) undefined value

<a id="multi"/><a id="multi-routine-modifier"/>
**multi**
*[«routine modifier»](appendix-b-grouped.html#routine-modifier)* &mdash;
marks *[routines](appendix-g-glossary.html#routine)* that can have sibling
with same name but different *[signature](appendix-g-glossary.html#signature)*,
when name is called, the one with matching signature is run
(*[multimethod dispatch](appendix-g-glossary.html#MMD)*) &mdash;
example: `multi sub name (...) {...}` &mdash;
opposite of: **[only](#only)**

<a id="my"/>
**my**
*[«scope declarator»](appendix-b-grouped.html#scope-declarator)* &mdash;
introduces lexically scoped names, which exists only in the
current *[scope](appendix-g-glossary.html#scope)* and cease to exist,
once this scope is executed



# [N](#nav-top)

<a id="backslash-N"/>
**\\N**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
anything but a (logical) [newline](#backslash-n)

<a id="backslash-n"/>
**\\n**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
logical (platform independent) newline,
not just a LINE FEED (LF) character (`u000A`)

<a id="nd-modifier"/>
<span class="you-provide">n</span>**:nd**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
demands the nth finding (:2nd), has many aliases
(**[:st](#st-modifier)**, **[:rd](#rd-modifier)**,
**[:th](#th-modifier)**) for correct spelling

<a id="name"/>
**name** *«routine method»* &mdash;
returns the name of of a *[routine](appendix-g-glossary.html#routine)*,
handy when it was stored in a scalar

<a id="need"/>
**[need](tablet-7-subroutines.html)** &mdash; 
just load a module, without import definitions
(see **[use](#use)** and **[import](#import)**)

<a id="new"/>
**new** &mdash;
creates a new object of a [class](#class)
(as in most other languages),
also name of the automatically called constructor method

<a id="NEXT-phaser"/>
**NEXT**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block, executed at [loop](appendix-b-grouped.html#loops)
continuation time, before any **[leave](#LEAVE-phaser)**

<a id="next"/>
**next**
*[«flow control»](appendix-b-grouped.html#jump-commands)* &mdash;
start the the next following loop *[iteration](appendix-g-glossary.html#interation)*

<a id="nextsame"/>
**nextsame** &mdash;
get from the dispatcher the next candidate with the
same *[signature](appendix-g-glossary.html#signature)*, similar to Javas *SUPER*

<a id="NF-compiler-var"/>
**\$\?NF**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
method name (options: `<NFC NFKC NFD NFKD>`) how strings are going to be normalized,
[**codes**](#codes) and [**bytes**](#bytes) have an optional
[pramameter](appendix-g-glossary.html#parameter) which method should be used,
that defaults to **\$\?NF**

<a id="Nil-type"/>
**Nil**
*[«undefined value type»](appendix-b-grouped.html#undefined-types)* &mdash;
unlike *undef* in Perl 5 it really means no value here &mdash;
example: *`@a = Nil, Nil;`* result array has zero elements

<a id="none"/>
**none**
*[«junctive op»](tablet-4-operators.html#junctions)* &mdash;
return **[True](#True)** when a value is not
part of a set, *[junctive](appendix-g-glossary.html#junction)* *NOT*
operator

<a id="normalize"/>
**normalize** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«string method»* &mdash;
normalize (repair) *[unicode](appendix-g-glossary.html#unicode)* 
*[string](#Str-type)*

<a id="not"/>
**not**
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
*[prefix](#prefix-category)* logical [*NOT*](appendix-g-glossary.html#not) operator,
converts to *[boolean context](appendix-g-glossary.html#bool-context)*,
low precedence version of **[!()](#exclamation-op)**

<a id="note"/>
**[note](tablet-5-io.html#note)** &mdash;
makes output via command line (**[$\*ERR](#ERR-global-var)**) like **[warn](#warn)**,
but appends a newline (**[\\n](#backslash-n)**) like **[say](#say)**

<a id="nude"/>
**nude**
( [--\>](#minus-minus-greater-signature) [Seq](#Seq-type)\[[Int](#Int-type)\])
*[«rat method»](tablet-2-basic-syntax.html#rational-number)* &mdash;
returns a list of numerator and denominator &mdash;
see also: [**numerator**](#numerator) and [**denominator**](#denominator)

<a id="Num-type"/>
**Num**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
Perl number (approximate "real", generally via floating point)

<a id="numerator"/>
**numerator**
( [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*[«rat method»](tablet-2-basic-syntax.html#rational-number)* &mdash;
returns the numerator of a rational number (value type **[Rat](#Rat-type)**
and **[FatRat](#FatRat-type)**),
opposite of [**denominator**](#denominator) &mdash;
see also: [**nude**](#nude)


# [O](#nav-top)

<a id="O-test"/>
**:O**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
tests if file is owned by real uid ([**\$\*UID**](#UID-global-var))

<a id="o-test"/>
**:o**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
tests if file is owned by effective uid ([**\$\*EUID**](#EUID-global-var))

<a id="of"/>
**of**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
inner type constraint that a *[routine](appendix-g-glossary.html#routine)*
imposes on its return value &mdash;
example: `subset Month of Int where { 1 <= $^a <= 12 }`

<a id="one"/>
**one**
*[«junctive op»](tablet-4-operators.html#junctions)* &mdash;
*[junctive](appendix-g-glossary.html#junction)*
*[XOR](appendix-g-glossary.html#xor)* operator,
**[True](#True)** if only one expression (of a
following list) is true in [*bool context*](appendix-g-glossary.html#bool-context) &mdash;
see also: **[|](#pipe-op)**

<a id="only"/>
**only**
*[routine modifier](appendix-b-grouped.html#routine-modifier)* &mdash;
permits only one *[routine](appendix-g-glossary.html#routine)*
of the same name in this block (no [MMD](appendix-g-glossary.html#MMD)) &mdash;
example: `only sub name (...) {...}` &mdash;
opposite of: **[multi](#multi)**

<a id="open"/>
**[open](tablet-5-io.html#open)**
*«path method»* &mdash;
establishes a connection to a file via a [*file handle*](IO-type)

<a id="OPTS-global-var"/>
**$\*OPTS**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
options from command line

<a id="or"/>
**or**
*[«logical op»](tablet-4-operators.html#logical-selection)* &mdash;
<a id="pipe-pipe-op"/><a id="logical-or"/>
**||**
*[«logical op»](tablet-4-operators.html#logical-selection)* &mdash;
*[infix](#infix-category)*, short circuit, logical,
*[OR](appendix-g-glossary.html#or)*, [evaluates](appendix-g-glossary.html#evaluation)
sequentially left to right its operands until one is [**True**](#True) in
[*bool context*](appendix-g-glossary.html#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 **[||](#logical-or)** &mdash;
example: `?('hurray' or 5)` returns `True` &mdash;
see also: [**any**](#any), [**orelse**](#orelse), [**err**](#err), [**xor**](#xor)

<a id="ord"/>
**ord** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*«string method»* &mdash;
converts a character into number according a character table
(*[unicode](appendix-g-glossary.html#unicode)*), reverse of **[chr](#chr)**

<a id="ords"/>
**ords** ([Str](#Str-type) [--\>](#minus-minus-greater-signature)
         [Array](#Array-type) [of](#of) [Int](#Int-type))
*«string method»* &mdash;
get the index numbers of some characters,
plural of **[ord](#ord)**, reverse of **[chrs](#chrs)**

<a id="orelse"/>
**orelse** *«logical op»* &mdash;
logical *[OR](appendix-g-glossary.html#or)* short circuit operator,
transferring an error code from first to second block/command, if
first do not succeed, similar to **[//](#defined-or)** &mdash;
example: `{...} orelse { note $! } `&mdash;
see also: **[andthen](#andthen)**

<a id="our"/>
**our**
*[«scope declarator»](appendix-b-grouped.html#scope-declarator)* &mdash;
introduces **[package](#package)**-scoped names for variables and
*[routines](#routine)*

<a id="OUT-global-var"/>
**\$\*OUT**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
[*file handle*](IO-type) for standard output (command line mostly) &mdash;
see also: **[$\*IN](#IN-global-var)**, in Perl 5: *STDOUT*

<a id="ov-modifier"/>
**:ov** *[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching at all positions just one time (with backtracking),
short for **[:overlap](#overlap#modifier)**

<a id="overlap-modifier"/>
**:overlap**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching at all positions just one time (with backtracking),
long for **[:ov](#ov-modifier)**



# [P](#nav-top)

<a id="p-test"/>
**:p** *[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
file is a named *[pipe](#pipe)* (FIFO),
or filehandle is a pipe

<a id="p-adverb"/>
**[:p](tablet-2-basic-syntax.html#paths)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
quote paths and create path object that know the right format of
the current **[\$\*KERNEL](#KERNEL-global-var)** &mdash;
example: **`Q :p /.../`** &mdash;
short for **[:path](#path-adverb)** or use **[qp](#qp-op)** directly

<a id="p-modifier"/>
**:p**(<span class="you-provide">n</span>)
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching only on the nth (n is an int) position (counting from
0), short for **[:pos](#pos-modifier)**

<a id="P5-modifier"/>
**:P5**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
activate old Perl 5 regex rules, alias to **[:Perl5](#Perl5-modifier)**

<a id="P5Regex-slang-var"/>
**$\~P5Regex**
*[«special var»](appendix-b-grouped.html#slang-variables)* &mdash;
current [grammar](#grammar) of the Perl 5
compatible regular expression *[slang](appendix-g-glossary.html#slang)*

<a id="pack"/>
**[pack](tablet-2-basic-syntax.html#pack)**
format values into or from a condensed format,
which is specified by keys or an own template

<a id="package"/>
**package** *«block modifier»* &mdash;
defines this Block or File as
namespace (almost like in Perl 5), some uses are now better to do
with **[module](#module)** and
**[class](#class)**

<a id="PACKAGE-compiler-var"/>
**&?PACKAGE**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
reference to the current package

<a id="package-declarator-category"/>
**package\_declarator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace for &mdash;
example: [**package**](#package), [**module**](#module), [**class**](#class)

<a id="Pair-type"/>
**Pair**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
object to hold a single key-to-value association, created with a
*[fat arrow](#fat-arrow)* or the *[adverbial notation](#colon-adverb)*

<a id="pairs"/>
**pairs**
*[«hash method»](tablet-3-variables#hash-methods)* &mdash;
returns all contents as an array or pairs (key,value)

<a id="panic-modifier"/>
**:panic**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
overwriting a possible set
**[:ratchet](#ratchet-modifier)** for all subrules
(activates backtracking)

<a id="Parcel-type"/>
**Parcel** 
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
*[arguments](appendix-g-glossary.html#argument)* in a comma list

<a id="parcel"/><a id="parcel-parameter-trait"/>
**parcel**
*[«parameter trait»](appendix-b-grouped.html#parameter-traits)* &mdash;
raw reference, will not be contextualized

<a id="parsed"/><a id="parsed-routine-trait"/>
**parsed**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
this macro will be parsed once, it is hygienic, but own and
later defined rules can't be applied, opposite of
**[reparsed](#reparsed)**

<a id="path-adverb"/>
**[:path](tablet-2-basic-syntax.html#paths)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
quote paths and create path object that know the right format of
the current **[$\*KERNEL](#KERNEL-global-var)** &mdash;
example: **`Q :path /.../`** &mdash;
long for **[:p](#p-adverb)** or use **[qp](#qp-op)** directly

<a id="perl"/>
**[perl](tablet-2-basic-syntax.html#perl)**
( [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«formater»* &mdash;
transforms data structure (object) into syntax of Perl 6 source code,
in most cases **[eval](#eval)** turn it back into the data structure,
use instead of Perl 5: *Data::Dumper* &mdash;
see also: [**gist**](#gist)

<a id="PERL-global-var"/>
**\$\*PERL**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
Perl version running under, in Perl 5: *\$\]* and *\$\^V* 

<a id="PERL-compiler-var"/>
**\$?PERL**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
Perl version this program is compiled for

<a id="Perl5-modifier"/>
**:Perl5**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
activate old Perl 5 regex rules, alias to **[:P5](#P5-modifier)**

<a id="pick"/>
**pick**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
select a number (optional first parameter) of random vaues (without
duplication), take **[roll](#roll)** to enable duplication

<a id="PID-global-var"/>
**\$\*PID**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
ID of the running process, in Perl 5: *\$\$* and *\$PID*


# [Pn](#nav-top)

<a id="pod-pod-var"/>
**$=pod**
*[«special var»](appendix-b-grouped.html#pod-variables)* &mdash;
object that contains all surrounding *[POD](appendix-g-glossary.html#POD)*
documentation

<a id="polar"/>
**polar** «Complex method» &mdash;
magnitude or angle corresponding to the
[complex number](#Complex-type) (only parameter),
the magnitude is non-negative, and the angle in the
[range](#range-op) -π ..\^ π &mdash;
see also: [**cis**](#cis), [**conj**](#conj), [**unpolar**](#unpolar)

<a id="pop"/>
**pop**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
removes and returns the last element in an array

<a id="pos-modifier"/>
**:pos**(<span class="you-provide">n</span>)
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching only on the <span class="you-provide">n</span>th position (counting from 0), long
for **[:p](#p-modifier)**

<a id="POST-phaser"/>
**POST**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block, assert postcondition,
executed at every block exit, after
**[LEAVE](#LEAVE-phaser)**

<a id="postcircumfix-category"/>
**postcircumfix**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
operator namespace of ops, that stay after one statement or
variable, but do surround a second &mdash;
example([square brackets](#postcircumfix-square-brackets-op)): `$a[2]`

<a id="postfix-category"/>
**postfix**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
operator namespace of ops, that stay after a statement or variable &mdash;
example ([**++**](#auto-increment)): [`$a++`](#auto-increment)

<a id="postfix-prefix-meta-operator-category"/>
**postfix\_prefix\_meta\_operator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace of
[metaoperator](appendix-g-glossary.html#metaoperator) that
[prefix](#prefix-category) (precedes) other operator
but stay [postfix](#postfix-category) (after) another term &mdash;
example ([**\>\>**](#greater-greater-metaop)): `@a >>++`

<a id="PRE-phaser"/>
**PRE**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block, assert precondition, executed
at every block entry, before [**ENTER**](#ENTER-phaser)

<a id="pred"/>
**pred** ([Num](#Num-type) $f)
*[«sequence traversion»](tablet-4-operators.html#traversing-sequence)* &mdash;
returns the predecessor of $f, alias to [**--**](#auto-decrement)
operator, opposite of [**succ**](#succ)

<a id="prefix-category"/>
**prefix**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
operator namespace of ops, that stay before a statement or variable &mdash;
example ([**++**](#auto-increment)): `++$a`

<a id="prefix-circumfix-meta-operator-category"/>
**prefix\_circumfix\_meta\_operator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace of [metaoperator](appendix-g-glossary.html#metaoperator) that
[circumfix](#circumfix-category) (surrounds) other
operator but stay [prefix](#prefix-category) (before) another term &mdash;
example: ([square brackets](#square-brackets-metaop)): `[+] @a` - sums up all elements of @a

<a id="prefix-postfix-meta-operator-category"/>
**prefix\_postfix\_meta\_operator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace of [metaoperator](appendix-g-glossary.html#metaoperator) that
[postfix](#postfix-category) other operator but stay
[prefix](#prefix-category) (before) another term &mdash;
example ([**\<\<**](#lower-lower-metaop)): `++<< @a`

<a id="print"/>
**[print](tablet-5-io.html#print)** &mdash;
sends a [string](#Str-type) to an output stream
(default is ([**$\*OUT**](#OUT-global-var), but can also be any 
[*file handle*](tablet-5-io.html#print-for-files) )
without adding a [newline](#backslash-n) like **[say](#say)**

<a id="print-subrule"/>
**\<print\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
a single printable character

<a id="printf"/>
**[printf](tablet-5-io.html#printf)** &mdash;
formats text like [**sprintf**](#sprintf) and
sends it to standard output like [**print**](#print)

<a id="prior-subrule"/>
**[\<prior\>](appendix-b-grouped.html#subrules)** &mdash;
standard grammar's rule for whatever the prior successful regex matched

<a id="promt"/>
**[prompt](tablet-5-io.html#prompt)** &mdash;
**[print](#print)** - ing text and reading a
line from **[$\*IN](#IN-global-var)**

<a id="proto"/><a id="proto-routine-modifier"/>
**proto**
*[«routine modifier»](appendix-b-grouped.html#routine-modifier)*
fallback for multi, if no multi *[routines](appendix-g-glossary.html#routine)*
*[signature](appendix-g-glossary.html#signature)* matches the
callers, a proto with same name is executed

<a id="punct-subrule"/>
**\<punct\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
a single punctuation character

<a id="push-array"/>
**push**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
appends a list of values to the end of an array
(see also **[pop](#pop)**)

<a id="push"/><a id="push-hash"/>
**push**
*[«hash op & method»](tablet-3-variables#hash-methods)* &mdash;
inserts a list of [pairs](#pair) in a Hash; if a
key already exists, it will point to an array of both values



# [Q](#nav-top)

<a id="Q-op"/>
**[Q](tablet-2-basic-syntax.html#quoting)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
most basic quoting operator,
provides just mechanism to encompass a string and return content,
understands a list of [adverbial modifier](appendix-b-grouped.html#quoting-adverbs)

<a id="q-op"/>
**[q](tablet-2-basic-syntax.html#single-quotes)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
simple quoting (slashes and '), alias to
**['...'](#single-quotes)** and **Q :q
/.../** and **Q [:single](#single-adverb) /.../**

<a id="q-adverb"/>
**[:q](tablet-2-basic-syntax.html#single-quotes)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
simple quoting (slashes and '), alias to
**['...'](#single-quotes)** and **q
/.../**, short for **[:single](#single-adverb)**

<a id="backslash-Q"/>
**\\Q\[<span class="you-provide">n</span>\]**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
all metacharacters within the brackets match as literal
characters

<a id="qp"/><a id="qp-op"/>
**[qp](tablet-2-basic-syntax.html#paths)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
path quoting, quoted string will be evaled as an file or
directory path, alias to [`Q :p /.../`](#p-adverb)
and [`Q :path /.../`](#path-adverb)

<a id="qq"/><a id="qq-op"/>
**[qq](tablet-2-basic-syntax.html#double-quotes)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
*double quoting*, **q** with interpolation of variables,
closures, and special chars, alias to
**["..."](#double-quotes)** and `Q :s, :a, :h, :f, :c, :b /.../`
and `Q` [`:qq`](#qq-adverb) `/.../` and `Q` [`:double`](#double-averb) `/.../`

<a id="qq-adverb"/>
**[:qq](tablet-2-basic-syntax.html#double-quotes)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
*double quoting*, **q** with interpolation of variables and
[blocks](#block) , alias to
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and `Q :s, :a, :h, :f, :c, :b /.../`,
short for **[:double](#double-adverb)**

<a id="qqx"/><a id="qqx-op"/>
**[qqx](tablet-2-basic-syntax.html#code)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
run as system call and return results, in Perl 5: *qx/.../*

<a id="quantifier"/>
**quantifier**
*[«grammatical category»](appendix-b-grouped.html#regex)* &mdash;
internal namespace for [*regex quantifier*](appendix-b-grouped.html#quantifier)
like [**\***](#asterisk-metachar)

<a id="Quasi-slang-var"/>
**$\~Quasi**
*[«special var»](appendix-b-grouped.html#slang-variables)* &mdash;
current [grammar](#grammar) of the quasiquoting language

<a id="quasi"/>
**quasi**
*«block modifier»* &mdash;
quasiquoting, the following commented (mostly in curly brackets)
will be [*compiled*](appendix-g-glossary.html#compilation) and the
*[AST](appendix-g-glossary.html#AST)* will be returned as result  &mdash;
see also: **[:code](#code-adverb)**

<a id="Quote-slang-var"/>
**$\~Quote**
*[«special var»](appendix-b-grouped.html#slang-variables)* &mdash;
current [grammar](#grammar) of the quoting
language as used by the [Q-operator](#Q-op) and any other quoting op

<a id="quote-category"/>
**quote**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
operator namespace used to define new 
[quoting ops](appendix-b-grouped.html#quoting-ops) with a macro

<a id="quote-mod-category"/>
**quote\_mod**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
operator namespace used to define new 
[quoting adverbs](appendix-b-grouped.html#quoting-adverbs)

<a id="quotemeta"/>
**quotemeta**
*«string method»* &mdash;
returns the input string with all non-"word" characters
([**\\W**](#backslash-W)) back-slashed

<a id="quotemarks-adverb"/>
**[:quotewords](tablet-2-basic-syntax.html#quote-words)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
split quoted string into words (on whitespaces) but with 
[quote protection](appendix-g-glossary.html#quote-protection),
long form of **[:ww](#ww-adverb)**,
used in **[\<\<...\>\>](#double-angle-brackets)**

<a id="qw"/><a id="qw-op"/>
**[qw](tablet-2-basic-syntax.html#quote-words)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
[circumfix](#circumfix-category) quoting operator that autoquotes words
and returns them as a list (as in Perl 5),
without [quote protection](appendix-g-glossary.html#quote-protection) and
evaluation of variables like [\<\< \>\>](#double-angle-brackets),
alias to **[\< \>](#angle-brackets-op)** or
**[Q](#Q-op)** **:q** **[:ww](#ww-adverb)** **/.../**

<a id="qx"/><a id="qx-op"/>
**[qx](tablet-2-basic-syntax.html#code)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
evaluate as Perl term (like **[eval](#eval)**) and return results (unlike Perl 5),
alias to **Q [:x](#x-adverb) /.../** or **Q [:exec](#exec-adverb) /.../**



# [R](#nav-top)

<a id="R-test"/>
**:R**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
check if file is readable by real uid ([**\$\*UID**](#UID-global-var))
/ gid ([**\$\*EUID**](#EUID-global-var))

<a id="r-test"/>
**:r**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
check if file is readable by effective uid ([**\$\*EUID**](#EUID-global-var))
/ gid ([**\$\*EUID**](#EUID-global-var))

<a id="backslash-R"/>
**\\R**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
anything but [return](#backslash-r)

<a id="backslash-r"/>
**\\r**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
carriage return (CR - `\u000D`), as in Perl 5

<a id="R-metaop"/>
**R**<span class="you-provide">op</span>
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
reverse operands &mdash;
example: `4 R- 3` result is `-1 = 3 - 4`

<a id="rand"/>
**rand** &mdash;
pseudo random number in [range](#range-op)
*0 ..\^ 1* (including 0, but not 1); for random list choices see
**[pick](#pick)** and **[roll](#roll)**

<a id="Range-type"/>
**Range**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
a *[Pair](#Pair-type)* of ordered endpoints, result of an evaluated term with
2 values and the [range operator](#range-op) in between `1 .. 10`, caret (^)
exludes a limit `1 ..^ 10` or can be used as *[upto-operator](#caret-upto")*

<a id="RangeIter-type"/>
**RangeIter**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
iterator over a **Range**

<a id="Rat-type"/>
**Rat**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
Perl rational number (exact **[Real](#Real-type)** numerator, limited denominator)

<a id="ratchet-modifier"/>
**:ratchet**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
deactivates backtracking, search starts at pos, where last match
ended

<a id="rd-modifier"/>
<span class="you-provide">n</span>**:rd**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
demands the nth finding, has many aliases (**:st :nd :th*) for
correct spelling (`:3rd`)

<a id="re"/>
**re**
«complex method» &mdash;
real part of a complex number &mdash;
see also: [**im**](#im), [**unpolar**](#unpolar), [**truncate**](#truncate)

<a id="read"/>
**[read](tablet-5-io.html#read)**
*«Buf method»* &mdash;
read <span class="you-provide">n</span> (first parameter) bytes from a buffer

<a id="readline"/>
**[readline](tablet-5-io.html#readline)** &mdash;
reads until the next [**\\n**](#backslash-n) from a
**[Buf](#Buf-type)** or **[Str](#Str-type)**

<a id="readonly"/><a id="readonly-parameter-trait"/>
**readonly**
*[«parameter trait»](appendix-b-grouped.html#parameter-traits)* &mdash;
immutable parameter

<a id="redo"/>
**redo**
*[«flow control»](appendix-b-grouped.html#jump-commands)* &mdash;
re-starts processing of the current loop turn

<a id="reduce"/>
**reduce**
*«list method»* &mdash;
alias to **[\[ \]](#square-brackets-metaop)**
[metaoperator](appendix-g-glossary.html#metaoperators) that applies an 
[*infix*](#infix-category) operator between each adjacent elements of a list
and evaluates this term to a single value &mdash;
example: `[+] @a` is equivalent to `@a.reduce(&[+])` numerical sum of all elements

<a id="Regex-type"/>
**Regex** 
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
builtin type that holds a compiled regular expression

<a id="regex"/>
**regex**
*[«routine type»](appendix-b-grouped.html#routine-types)* &mdash;
a pattern definition (without
**[:ratchet](#ratchet-modifier)** and
**[:sigspace](#sigspace-modifier)**), can be put in
a **[grammar](#grammar)**, similar to *qr/.../* in
Perl 5, see **[rule](#rule)**, **[token](#token)**

<a id="regex-adverb"/>
**[:regex](tablet-2-basic-syntax.html#regex)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
parse as quoted string as regex

<a id="Regex-slang-var"/>
**$\~Regex**
*[«special var»](appendix-b-grouped.html#slang-variables)* &mdash;
current [grammar](#grammar) of the regex language
as used by **[rx](#rx)** and any regex operator and
method, tells the parser how to parse regular expressions

<a id="reparsed"/><a id="reparsed-routine-trait"/>
**reparsed**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
after parsing this **[macro](#macro)**, it will
be reparsed, so that not hygienic, but its own and later defined
rules can be applied, opposite of **[parsed](#parsed)**

<a id="repeat"/>
**[repeat](tablet-6-blocks.html#repeat)**
*[«block modifier»](appendix-b-grouped.html#loops)* &mdash;
can be put before a *[block](#block)* so that
**[while](#while)** or
**[until](#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

<a id="rename"/>
**[rename](tablet-5-io.html#rename)** &mdash;
changes names of files and directories

<a id="return"/>
**return**
*[«flow control»](appendix-b-grouped.html#jump-commands)* &mdash;
forces execution to leave this *[routine](appendix-g-glossary.html#routine)*
and sets the return value &mdash; see also: **[leave](#leave)**

<a id="returns"/>
**returns** 
*[«routine trait»](appendix-b-grouped.html#)* &mdash;
describing the type of value is produced (returned)

<a id="reverse"/>
**reverse**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
returns all the members in the opposite order. Use
**[flip](#flip)** to turn a string back to front and
**[invert](#invert)** for hashes

<a id="rindex"/>
**rindex** *«string method»* &mdash;
finds the last occurrence of a
substring in a string and returns the numerical position,
opposite or **[index](#index)**

<a id="rmdir"/>
**[rmdir](tablet-5-io.html#rmdir)** &mdash; 
deletes a directory with given name



# [Rn](#nav-top)

<a id="role"/>
**role** *«block modifier»* &mdash;
container for methods that can extend a class using **[does](#does)**

<a id="ROLE-compiler-var"/>
**$?ROLE**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
current role object

<a id="ROLE-namespace-compiler-var"/>
**::?ROLE**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
name of the current role

<a id="roll"/>
**roll**
*[«array method»](tablet-3-variables#array-methods)* &mdash;
selects <span class="you-provide">n</span> (first parameter) values from an array,
duplication can occur (like rolling dice),
**[pick](#pick)** works without duplication

<a id="roots"/>
**roots** (Num $f, Int $n) &mdash; compute the $n'th root of $f &mdash;
see also **[exp](#exp)** and **[log](#log)**

<a id="rotate"/>
**[rotate](tablet-3-variables)**
*[«array method»](tablet-3-variables#array-methods)* &mdash;
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 id="round"/>
**round**
([Num](#Num-type) $f [--\>](#minus-minus-greater-signature) [Int](#Int-type))
«num method» &mdash;
returns the nearest whole number &mdash;
example: `round 5.5` returns `6`, `round -5.5` returns `-5` &mdash;
see also: [**abs**](#abs), [**ceiling**](#ceiling), [**floor**](#floor),
[**truncate**](#truncate)


<a id="roundrobin"/>
**roundrobin**
*[«array method»](tablet-3-variables#array-methods)* &mdash;
kind of **[zip](#zip)** that ignores empty lists &mdash;
example: `roundrobin([1..3],[1,2],[1])` returns `1,1,1,2,2,3`

<a id="ROUTINE-compiler-var"/>
**&?ROUTINE**
*[«special var»](appendix-b-grouped.html#compiler-hint-variables)* &mdash;
current *[routine](appendix-g-glossary#routine)* object

<a id="routine-declarator-category"/>
**routine\_declarator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace for [routine declarators](appendix-b-grouped.html#routine-types)

<a id="rule"/>
**rule**
*[«routine type»](appendix-b-grouped.html#routine-types)* &mdash;
alias for **[regex](#regex)**
**[:ratchet](#ratchet-modifier)**
**[:sigspace](#sigspace-modifier)** in a [grammar](#grammar) &mdash;
see also: **[regex](#regex)**, **[token](#token)**

<a id="run"/>
**[run](tablet-5-io.html#processes)** &mdash;
executes an external program, and returns control to the caller
once the program has exited

<a id="runinstead"/>
**[runinstead](tablet-5-io.html#processes)** &mdash;
executes an external program that replaces the caller, because
there will be no return

<a id="rw-routine-trait"/>
**rw**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
marks a *[routine](appendix-g-glossary.html#routine)* as returning an 
*[lvalue](appendix-g-glossary.html#lvalue)*

<a id="rw-parameter-trait"/>
**rw**
*[«parameter trait»](appendix-b-grouped.html#parameter-traits)* &mdash;
mutable parameter (rw stands for: read write), can be changed by the
*[routine](appendix-g-glossary.html#routine)* given to

<a id="rw-modifier"/>
**:rw**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
gives the regex the right to change the string (operand)

<a id="rx"/><a id="rx-op"/>
**[rx](tablet-9-regexes.html#regex-operators)**
*[«regex quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
creates anonymous regex, that can me then assigned into a var,
alias to **[Q](#Q-op)**
**[:regex](#regex-adverb)** **/.../** and
**[regex](#regex)** *(routine type)*



# [S](#nav-top)

<a id="s-op"/>
**[s/ / /](tablet-9-regexes.html#regex-operators)**
*[«regex quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
perform a substitution based on rx-matches in place, creates
anonymous regex, alias to **Q [:subst](#subst-adverb)
/.../.../** and **[.subst()](#subst)** &mdash;
see also **[ss/.../.../](#ss-op)** and **[m/.../](#m-op)**

<a id="S-metaop"/>
**S**<span class="you-provide">op</span>
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
force sequential (synchronous) evaluation,
suppresses any explicit or implicit parallelism

<a id="S-test"/>
**:S**
*[«test method»](appendix-b-grouped.html#test-methods)* &mdash;
file is a socket

<a id="s-test"/>
**:s**
*[«test method»](appendix-b-grouped.html#test-methods)* &mdash;
file has size greater than 0 (zero)

<a id="s-adverb"/>
**:s**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
demands evaluation of scalar variables that start with the
**[$-sigil](#dollar-sigil)**, long form of
**[:scalar](#scalar-adverb)**, included in
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="s-modifier"/>
**:s**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
whitespace separates now subregex and don't stand for spaces to
look for, short for **[:sigspace](#sigspace-modifier)**,
**[ms/.../](#ms-op)** is alias to
**m:sigspace/.../**

<a id="backslash-S"/>
**\\S**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
anything but whitespace

<a id="backslash-s"/>
**\\s**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
any whitespace character,
horizontal ([**\\h**](#backslash-h)) and vertical ([**\\v**](#backslash-v)** )

<a id="same-subrule"/>
**\<?same\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
match the zero-width space between two identical chars

<a id="samecase-modifier"/>
**:samecase**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
only for substitutions, replacing with chars that have the same
case pattern as the replaced, long for
**[:ii](#ii-modifier)**

<a id="samemark-modifier"/>
**:samemark**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
substitute with chars that has same mark/accent pattern as the
matched string, long for **[:mm](#mm-modifier)**

<a id="samespace-modifier"/>
**:samespace**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
smart space mapping for substitutions, long alias of
**[:ss](#ss-modifier)** &mdash;
example: *ss/teh hsa/the has/;* &mdash;
see also: **[:sigspace](#sigspace-modifier)**

<a id="say"/>
**[say](tablet-5-io.html#say)** &mdash;
makes output via command line
([**$\*OUT**](#OUT-global-var)) like
[**print**](#print)**, but appends a [newline](#backslash-n)

**[say](tablet-5-io.html#say-for-files)** &mdash;
*«handle method»* &mdash; writes a stream into a file and appends a
[**\\n**](#backslash-n)

<a id="Scalar-type"/>
**Scalar**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
object to hold a Perl scalar, a variable for a single value of any type

<a id="scalar-adverb"/>
**[:scalar](tablet-2-basic-syntax.html#interpolation)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
demands evaluation of scalar variables that start with the
**[$-sigil](#dollar-sigil)**, long form of
**[:s](#s-adverb)**, included in
**["..."](#double-quotes)**,
**[qq/.../](#qq-op)** and
**[\<\<...\>\>](#double-angle-brackets)**

<a id="scope-declarator-category"/>
**scope\_declarator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace for
*[scope declarators](appendix-b-grouped.html#scope-declarator)* in case you want
to create your own

<a id="seed"/>
**seed** &mdash;
initialize a random number generator, optionally with a value

<a id="Set-type"/>
**Set**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
unordered collection of values that allows no duplicates

<a id="set"/>
**set**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
creates a **[Set](#Set-type)** &mdash;
example:

<a id="sigil"/><a id="sigil-category"/>
**sigil**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
word to name the namespace for [sigils](appendix-b-grouped.html#sigils),
used to redifine them or define your own with a macro

<a id="sign"/>
**sign** ($f) &mdash;
 1 if $f is greater than 0, -1 if \< 0, 0 when equal 0,
 undefined when undefined &mdash;
 see also: [**abs**](#abs), [**round**](#round)

<a id="Signature-type"/>
**Signature**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
object type to hold all information a signature like parameter
types and values, return type, etc.

<a id="signature"/><a id="signature-routine-trait"/>
**signature**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
*[signature](appendix-g-glossary.html#signature)* of a
*[routine](appendix-g-glossary.html#routine)*,
normally declared implicitly, by providing a parameter list and/or return type
between name and the corresponding block

<a id="sigspace-modifier"/>
**:sigspace**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
whitespace separates now subregex and don't stand for spaces to
look for, long for for **[:s](#s-modifier)**,
**[ms/.../](#ms-op)** is alias to
**m:sigspace/.../**

<a id="sin"/>
**[sin](operators.html)**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
sine, trigonometric function, takes angle in radian; see also
**[to-radians](#to-radians)**,
**[cos](#cos)**, **[tan](#tan)**

<a id="single-adverb"/>
**[:single](tablet-2-basic-syntax.html#single-quotes)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
simple quoting (slashes and '), alias to
**['...'](#single-quotes)** and
**[q/.../](#q-op)**, long for
**[:q](#q-adverb)**

<a id="sleep"/>
**sleep** &mdash;
attempt to sleep (stop the program) for up to
<span class="you-provide">f</span> (only parameter)
seconds (with sub-second resolution)

<a id="slurp"/>
**[slurp](tablet-2-basic-syntax.html#files)**
*«path and file handle method»* &mdash;
reads an entire file into a string without a [*file handle*](IO-type)



# [Sn](#nav-top)

<a id="so"/><a id="so-op"/>
**so**
*[«context op»](appendix-b-grouped.html#contextualizers)* &mdash;
converts value into the *[boolean context](tablet-4-operators.html#bool-context)*,
low precedence alternative to
**[?](#question-mark-op)**

<a id="SoftRoutine-type"/>
**SoftRoutine**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
*[routine](appendix-g-glossary.html#routine)* that is committed to
staying mutable (changable)

<a id="sort"/>
**sort**
*«list method»* &mdash;
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 ^](#caret-twigil))
or shorter with `sort &[leg], @input` ([see leg](#leg))
or yet even shorter by `sort ~*, @input` ([see ~](#tilde-context))
for sorting in [*string context*](appendix-g-glossary.html#string-context)

<a id="space-subrule"/>
**\<space\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
single white space char aka [**\\s**](#backslash-s)

<a id="special-variable-category"/>
**special\_variable**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
namespace to define and redefine
[special variables](appendix-b-grouped.html#special-variables) with a macro

<a id="splice"/>
**splice**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
remove on $pos (first parameter) $n (second - optional) values
and replace them with values (third - optional)

<a id="split"/>
**split** &mdash;
splits a string according a delimiter (string or regex)
into an array of substrings &mdash;
example: `split(rx/-/, "1-2-4-5")` returns `1,2,3,4` &mdash;
see also: [**comb**](#comb)

<a id="sprintf"/>
**[sprintf](tablet-2-basic-syntax.html#sprintf)**
*«formater»* &mdash;
inserts formated values out of variables into a
string like **[printf](#printf)**, but returns the
string instead of outputting it

<a id="sqrt"/>
**sqrt** ([Num](#Num-type) $f) &mdash;
square root of $f &mdash; see also: **[exp](#exp)**

<a id="ss"/><a id="ss-op"/>
**[ss/ / /](tablet-9-regexes.html#substitution)**
*[«regex quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
performs **[rx](#rx)** based substitution, spaces
are just subrule separators,
`ss/.../.../` is alias to [`s:ss/.../.../`](#ss-modifier) &mdash;
example: `ss/teh hsa/the has/;`

<a id="ss-modifier"/>
**:ss**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
only for for substitution, whitespace separates subregexes like
**[:sigspace](#sigspace-modifier)**, but also in the
second part, short alais of **[:samespace](#samespace-modifier)**

<a id="st-modifier"/>
**:st**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
demands the nth finding, has many aliases (:nd :rd :th) for
correct spelling (:1st)

<a id="START-phaser"/>
**START**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block or statement, executed on
first ever execution, once per closure clone

<a id="Stash-type"/>
**Stash**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
a symbol table hash (package, module, class, lexpad, etc)

<a id="stat"/>
**stat**
*[«test method»](appendix-b-grouped.html#test-methods)* &mdash;
available information about a file or link
(call `stat :link` instead of Perl 5: *lstat*)

<a id="state"/>
**state**
*[«scope declarator»](appendix-b-grouped.html#scope-declarator)* &mdash;
introduces lexically scoped but persistent names (known only in
the enclosing block, but retain their values between invocations)

<a id="statement-cotroll"/>
**statement\_control**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace for block modifier like
[conditionals](appendix-b-grouped.html#conditionals) or
[loops](appendix-b-grouped.html#loops)
that stay in front of it

<a id="statement-mod-cond-category"/>
**statement\_mod\_cond**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace for words that come after a statement and
handle if the statement will be executed &mdash;
example (if): `$a++ if $a > 3`

<a id="statement-mod-loop-category"/>
**statement\_mod\_loop**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace for
[special group of block modifier](appendix-b-grouped.html#loops)
that turn the [block](#block) into a loop

<a id="statement-prefix-category"/>
**statement\_prefix**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace for block modifier &mdash;
example: [**do**](#do)

<a id="Str-type"/>
**Str**
*[«immutable type»](appendix-b-grouped.html#immutable-types)* &mdash;
Perl string - a finite sequence of [unicode](appendix-g-glossary.html#unicode)
characters

<a id="Sub-type"/>
**Sub**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
Perl subroutine object

<a id="sub"/>
**[sub](tablet-6-blocks.html#sub)**
*[«routine type»](appendix-b-grouped.html#routine-types)* &mdash;
defines a *[routine](appendix-g-glossary.html#routine)*,
a block callable by name &mdash; example: `name();`

<a id="Submethod-type"/>
**Submethod**
*[«mutable type»](appendix-b-grouped.html#mutable-types)* &mdash;
**[method](#method)** than can't be inherited by other classes,
only called by objects of the class, where it is defined

<a id="submethod"/>
**submethod**
*[«routine type»](appendix-b-grouped.html#routine-types)* &mdash;
defines methods, not inherited by subclasses like a **[method](#method)**

<a id="subset"/>
**subset** &mdash;
define a subtype &mdash;
example: `subset Month of Int where { 1 <= $\^a <= 12 }`

<a id="subst"/>
**[subst](tablet-9-regexes.html#substitution)**
*«string method»* &mdash; 
method alias to
*[s/.../.../](#s-op) , $str.subst( /pattern/,
"replacement" )*, equals $str \~\~ s/pattern/replacement/;

<a id="subst-adverb"/>
**[:subst](tablet-2-basic-syntax.html#regex)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
parse as [substitution regex](tablet-9-regexes.html#substitution)
, **Q [:subst](#subst-adverb) /.../.../** is alias to
**[s/.../.../](#s-op)**

<a id="substr"/>
**substr** ([Str](#Str-type) $string, [Int](#Int-type) $start, [Int](#Int-type)
             $length? [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«string method»* &mdash;
return a substring of $string from $start position and maybe with $length,
works like in Perl 5 except fourth parameter was cut &mdash;
example: `substr('Hackathon', 1, 3)` returns `'ack'` &mdash;
see also: [**chop**](#chop)

<a id="succ"/>
**succ** ([Num](#Num-type) $f)
*[«sequence traversion»](tablet-4-operators.html#traversing-sequence)* &mdash;
returns the successor of $f, alias to **[++](#auto-increment)**
operator, opposite of **[pred](#pred)**

<a id="supersede"/>
**supersede**
*[«scope declarator»](appendix-b-grouped.html#scope-declarator)* &mdash;
replaces definitions of an existing name, e.g. methods and
attributes of a **[class](#class)** or **[grammar](#grammar)** &mdash;
see also: **[augment](#augment)**



# [T](#nav-top)

<a id="t-test"/>
**:t**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
[*file handle*](IO-type) is opened to a "tty" (terminal)

<a id="backslash-t"/>
**\\T**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
anything but a tab

<a id="backslash-t"/>
**\\t**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
tab `\u0009`, not visible character (control char)

<a id="take"/>
**[take](tablet-6-blocks.html#gather-and-take)**
can add several item to the list of return values of a
**[gather](#gather)** block

<a id="tan"/>
**tan**
*[«numeric op»](tablet-4-operators.html#numeric-context)* &mdash;
tangent, trigonometric function, takes angle in radian; see also
**[to-radians](#to-radians)**,
**[cos](#cos)**, **[sin](#sin)**

<a id="temp"/>
**temp** &mdash; 
, in Perl 5: *local*

<a id="term"/><a id="term-category"/>
**term**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
namespace of terms, used to redifine them or make a new with a macro &mdash;
example: [**\***](#asterisk-term)

<a id="th-modifier"/>
<span class="you-provide">n</span>**:th**
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
demands the nth finding, has many aliases (:st :nd :rd) for
correct spelling (:2nd)

<a id="tighter"/>
**tighter**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
specifies the [precedence of an operator](appendix-b-grouped.html#table-of-precedence)
higher than an existing operator

<a id="titlecase"/>
**titlecase** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«string method»* &mdash;
performs a [Unicode](appendix-g-glossary.html#unicode) titlecase operation
on the first character of each word of the string

<a id="to-adverb"/>
**[:to](tablet-2-basic-syntax.html#heredocs)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
defines end marker for the following heredoc, **:to** is short
for **[:heredoc](#heredoc-adverb)**

<a id="to-radians"/>
**to-radians** &mdash;
convert from $base (second parameter) to radians,
opposite of **[from-radians](#from-radians)**

<a id="token"/>
**token**
*[«routine type»](appendix-b-grouped.html#routine-types)* &mdash;
**[regex](#regex)** method without backtracking,
alias to **[regex](#regex)**
**[:ratchet](#ratchet-modifier)**, part of a
**[grammar](#grammar)** , see also
**[rule](#rule)**

<a id="touch"/>
**touch** «filehandle method» &mdash;
update timestamps on a file like the Unix command

<a id="tr-op"/><a id="tr"/>
**[tr///](tablet-9-regexes.html#transliteration)**
*[«quoting op»](appendix-b-grouped.html#quoting-ops)* &mdash;
transliteration (as in Perl 5), translating some character in a
string into others, alias to **Q [:trans](#trans-adverb) /.../.../**

<a id="trait-auxiliary-category"/>
**trait\_auxiliary**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
example: [**is**](#is)

<a id="trait-verb-category"/>
**trait\_verb**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
example : **[of](#of)**

<a id="trans"/>
**[trans](regexes.html#transliteration)**
*«string method»* &mdash;
transliteration, replacing several specific character of a string with other chars,
much more effective than with several **[s/.../.../](#s-op)**
method alias for **[tr/.../.../](#tr-op)** operator,
`$str.trans( %mapping )` equals
`$str ~~ tr/%mapping.sort.keys/%mapping.sort.values/;`

<a id="trans-adverb"/>
**[:trans](tablet-2-basic-syntax.html#regex)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
evals the quoted as [transliteration](tablet-9-regexes.html#transliteration)
aka `tr /.../.../` aka `.trans("..." => "...")`

<a id="Trans-slang-var"/>
**$\~Trans**
*[«special var»](appendix-b-grouped.html#slang-variables)* &mdash;
current [grammar](#grammar) of the
transliteration language (used by **[trans()](#trans)**
aka **[tr/.../.../](#tr-op)**)

<a id="triangle"/>
**triangle** *«list method»* &mdash;
alias to **[[\\ ]](#square-brackets-backslash-metaop)**
[metaoperator](appendix-g-glossary.html#metaoperators) &mdash;
example: `[\+] @a = @a.triangle(&[+])`

<a id="trim"/>
**trim** *«string method»* &mdash;
returns a copy of the string, with leading and trailing whitespace
([**\\s**](#backslash-s)) removed &mdash;
see also: [**chomp**](#chomp)

<a id="True"/>
**True** &mdash; *[boolean](#Bool-type)* value aka
Bool::True, 1 in [*numeric context*](appendix-g-glossary.html#numeric-context),
opposite of **[False](#False)**

<a id="truncate"/>
**truncate**
([Num](#Num-type) $f [--\>](#minus-minus-greater-signature) [Int](#Int-type))
*«num method»* &mdash;
just truncates the fractional part &mdash;
examples: `truncate 4.27` returns `4`, `truncate -5.5` returns `-5` &mdash;
see also: [**abs**](#abs), [**conjugate**](#conjugate),
          [**round**](#round), [**sign**](#sign)

<a id="trusts"/>
**trusts** &mdash;
allows a class the acess to otherwised sealed namespaces

<a id="twigil"/><a id="twigil-category"/>
**twigil**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
internal namespace for [twigils](appendix-g-glossary.html#twigil),
used to redifine them or define your own with a macro

<a id="type-declarator-category"/>
**type\_declarator**
*[«grammatical category»](appendix-b-grouped.html#categories)* &mdash;
example: **[subset](#subset)**

<a id="TZ-global-var"/>
**$\*TZ** *[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
local time zone



# [U](#nav-top)

<a id="u-test"/>
**:u**
*[«test method»](appendix-b-grouped.html#test-methods)* &mdash;
report if file has setuid bit set

<a id="backslash-U"/>
**\\U\[<span class="you-provide">n</span>\]**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
everything within the brackets is uppercase

<a id="uc"/><a id="uc-op"/>
**uc** ([Str](#Str-type) [--\>](#minus-minus-greater-signature) [Str](#Str-type))
*«string method»* &mdash;
return a copy of a string where all characters are uppercase,
usable as operator and as method &mdash;
see also: [**fc**](#fc) and [**lc**](#lc)

<a id="UID-global-var"/>
**\$\*UID** *[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
real user ID of the running process
(**[\$\*PID](#PID-global-var)**) owner (user), in Perl 5: *\@\<* and *\$UID* 

<a id="UNDO-phaser"/>
**UNDO**
*[«closure trait»](appendix-b-grouped.html#closure-traits)* &mdash;
marks as a prefix a special block, executed at every
unsuccessful block exit, part of
**[LEAVE](#LEAVE-phaser)** queue

<a id="uniq"/>
**uniq** *«list method»* &mdash;
returns only unique elements of a list (no value twice)

<a id="unless"/>
**[unless](tablet-6-blocks.html#unless)**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
if the following expression *[evals](#evaluation)*
to **[False](#False)**, the block after that will
be run, can also be written at the end of an expression, opposite of
**[if](#if)**,  alias to **if** **[not](#not)**,
no **[elsif](#elsif)** or **[else](#else)** is allowed to follow

<a id="unpolar"/>
**unpolar** *«Complex method»* &mdash;
see also: [**cis**](#cis), [**conj**](#conj), [**polar**](#polar)

<a id="until"/>
**[until](tablet-6-blocks.html#until)**
*[«block modifier»](appendix-b-grouped.html#loops)* &mdash;
runs block repeatedly as long as the following expression
*[evals](#evaluation)* to
**[False](#False)**, can be combined with
**[repeat](#repeat)**, can also be written at the
end of an expression, opposite of **[while](#while)**,
alias to **while** **[not](#not)**

<a id="unwrap"/>
**unwrap** &mdash;
remove an enclosing *[routine](appendix-g-glossary.html#routine)*,
opposite of **[wrap](#wrap)**

<a id="upper-subrule"/>
**\<upper\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
a single uppercase character

<a id="uri"/>
**[uri](io.html)** &mdash;
returns IO::Streamable descendant for accessing content of that
URI (only pramameter typed **[Str](#Str-type)**)

<a id="USAGE-compiler-var"/>
**$?USAGE**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
default usage message generated at compile time

<a id="use"/>
**[use](subroutines.html)** &mdash;
load a module, check Perl version, import definitions (vars and routines),
see also **[need](#need)** and **[import](#import)**)



# [V](#nav-top)

<a id="backslash-V"/>
**\\V**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
anything but vertical whitespace ([**\\v**](#backslash-v))

<a id="backslash-v"/>
**\\v**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
a vertical *[unicode](appendix-g-glossary.html#unicode)* whitespace character
([LF](#backslash-n) | [CR](#backslash-r) | [FF](#backslash-f) | Line Tab | 
Next Line | Line Separator | Paragraph Separator), in numbers: 
`u000A | \u000B | \u000C | \u000D | \u0085 | \u2028 | \u2029 | \u000D\u000A`,
together with [vertical whitespace](#backslash-v) this sums up all
[whitespace](#backslash-s) character

<a id="value"/>
**value**
*[«pair method»](tablet-3-variables#pair)* &mdash;
gets value (second) value of a pair (opposite of **[key](#key)**) &mdash;
example: `(key => 'val').value;` returns `'val'`

<a id="values-array"/>
**values**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
returns an array of values like the var itself in
[list context](appendix-g-glossary.html#list-context) does

<a id="values"/>
**values**
*[«hash method»](tablet-3-variables#hash-methods)* &mdash;
returns an array of just the values &mdash;
example: `(1 => 2, 3 => 4).values;` returns `2,4`

<a id="VM-global-var"/>
**\$\*VM**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
running virtual machine, might want to use `$*VM.name` &mdash;
see also: **[\$\*DISTRO](#DISTRO-global-var)** and
**[\$\*KERNEL](#KERNEL-global-var)**

<a id="VM-compiler-var"/>
**\$\?VM**
*[«special var»](appendix-b-grouped.html#global-variables)* &mdash;
virtual machine the program is compiled for &mdash;
see also: **[\$\?DISTRO](#distro-compiler-var)** and
**[\$\?KERNEL](#kernel-compiler-var)**



# [W](#nav-top)

<a id="W-test"/>
**:W**
*[«test method»](appendix-b-grouped.html#test-methods)* &mdash;
check if file is writeable by real uid ([**\$\*UID**](#UID-global-var)) /
gid ([**\$\*GID**](#GID-global-var))

<a id="w-test"/>
**:w**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
check if file is writeable by effective uid ([**\$\*EUID**](#EUID-global-var))
/ gid ([**\$\*EGID**](#EGID-global-var))

<a id="w-adverb"/>
**[:w](tablet-2-basic-syntax.html#quote-words)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
split quoted string on words (on whitespaces),
no [quote protection](appendix-g-glossary.html#quote-protection),
short form of **[:words](#words-adverb)**, used in **[qw/.../](#qw-op)**

<a id="backslash-W"/>
**\\W**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
anything but a word character ([**\\w**](#backslash-w))

<a id="backslash-w"/>
**\\w**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
a word character (*[unicode](appendix-g-glossary.html#unicode)* alphanumeric -
A..Z, a..z,0..9, "\_")

<a id="pipe-w"/>
**\<|w\>**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
word boundary, zero width space between two **\\w**, alias to
**[\<wb\>](#wb-subrule)**, opposite is **\<!|w\>**  &mdash;
see also: **[\<|c\>](#pipe-c)** and **[\<|g\>](#pipe-g)**

<a id="wait"/>
**[wait](tablet-5-io.html#processes)** &mdash;
waits for a child process to terminate and returns the child status object,
process ID in [*numeric context*](appendix-g-glossary.html#numeric-context)

<a id="warn"/>
**[warn](tablet-5-io.html#warn)** &mdash;
makes output via standart error output (**[$\*ERR](#ERR-global-var)**)
like **[note](#note)**, but works more like **[print](#print)**,
without appending a [**\\n**](#backslash-n)

<a id="wb-subrule"/>
**\<wb\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
zero-width word boundary between an 
**[\\w](#backslash-w)** and a **[\\W](#backslash-W)** character,
alias to **[\<|w\>](#pipe-w)** &mdash;
see also **[\<ww\>](#ww-subrule)**

<a id="WHAT-introspection"/>
**WHAT**
*[«introspection method»](appendix-b-grouped.html#object-introspection)* &mdash;
short name of the class that an object belongs to

<a id="Whatever"/><a id="Whatever-type"/>
**Whatever**
*[«undefined value type»](appendix-b-grouped.html#undefined-types)* &mdash;
Wildcard (like **[Any](#Any-type)**, but subject to do-what-I-mean via
*[multi method dispatch](appendix-g-glossary.html#MMD)*),
alias to **[\*](#asterisk)**

<a id="WHEN-introspection"/>
**WHEN**
*[«introspection method»](appendix-b-grouped.html#object-introspection)* &mdash;
(reserved for events?)

<a id="when"/>
**[when](tablet-6-blocks.html#when)**
*[«conditional»](appendix-b-grouped.html#conditionals)* &mdash;
executes its following code block, when parameter matches
against **[$\_](#context-var)** (set by
**[given](#given)** or
**[for](#for)**), see also:
**[default](#default)**

<a id="WHENCE-introspection"/>
**WHENCE**
*[«introspection method»](appendix-b-grouped.html#object-introspection)* &mdash;
autovivification of closures

<a id="WHERE-introspection"/>
**WHERE**
*[«introspection method»](appendix-b-grouped.html#object-introspection)* &mdash;
memory address of the object

<a id="where"/>
**where** &mdash;
defines subtypes of data &mdash;
example: `subset Month of Int where { 1 <= $\^a <= 12 }`

<a id="WHICH-introspection"/>
**WHICH**
*[«introspection method»](appendix-b-grouped.html#object-introspection)* &mdash;
object ID (type)

<a id="while"/>
**[while](tablet-6-blocks.html#while)**
*[«block modifier»](appendix-b-grouped.html#loops)* &mdash;
runs block repeatedly as long as the following expression
*[evals](#evaluation)* to
**[True](#True)**, can be combined with
**[repeat](#repeat)**, can also be written at the
end of an expression, opposite of **[until](#until)**

<a id="WHO-introspection"/>
**WHO**
*[«introspection method»](appendix-b-grouped.html#object-introspection)* &mdash;
package, that support that object, long name in *[string
context](tablet-4-operators.html#string-context)*

<a id="WHY-introspection"/>
**WHY**
*[«introspection method»](appendix-b-grouped.html#object-introspection)* &mdash;
documentation of that object&mdash;
see also: **[\#=](#pound-equal)**

<a id="will-do-routine-trait"/>
**will do**
*[«routine trait»](appendix-b-grouped.html#routine-traits)* &mdash;
block of code executed when the *[routine](appendix-g-glossary.html#routine)*
is called, normally declared implicitly,
by providing a block after the subroutine's signature definition

<a id="words"/>
**words**
*«string method»* &mdash;
splits a [string](#Str-type) into a list of words &mdash;
example: `$input.words($limit)` equals [`$input.comb( / \S+ /, $limit )`](#comb) &mdash;
see also [**lines**](#lines)

<a id="words-adverb"/>
**[:words](tablet-2-basic-syntax.html#quote-words)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
split quoted string on words (on whitespaces),
no [quote protection](appendix-g-glossary.html#quote-protection),
long form of **[:w](#w-adverb)**, used
in **[qw/.../](#qw-op)**

<a id="wrap"/>
**wrap** &mdash;
creates enveloping [routine](#routine) that is called instead of the original,
but can forward to it, opposite of **[unwrap](#unwrap)**

<a id="write"/>
**[write](tablet-5-io.html#read)**
*«Buf method»* &mdash;
writes content of all parameter into that buffer

<a id="ws-subrule"/>
**\<ws\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
whitespace between words aka [**\\s\***](#backslash-s)

<a id="ww-adverb"/>
**[:ww](tablet-2-basic-syntax.html#quote-words)**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
split quoted string into words (on whitespaces) but with
[quote protection](appendix-g-glossary.html#quote-protection),
short form of [**:quotewords**](#quotewords-adverb),
used in [**\<\<...\>\>**](#double-angle-brackets)

<a id="ww-subrule"/>
**\<ww\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
zero-width space inside of a word between two
**[\\w](#backslash-w)** character, see also
**[\<wb\>](#wb-subrule)**



# [X](#nav-top)

<a id="X-op"/>
**X**
*[«list op»](tablet-4-operators.html#list-generation)* &mdash;
Cross product of two arrays, alias of
**[cross](#cross)** method &mdash;
example: `1,2 X 3,4` retuns `1,3,1,4,2,3,2,4;`

<a id="x-op"/>
**x**
*[«string op»](tablet-4-operators.html#string-context)* &mdash;
string replicate operator to single string &mdash;
example: `'ab' x 3` returns `'ababab';`

<a id="X-metaop"/>
**X**<span class="you-provide">op</span>
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
cross product with hyper operator, alias of
**[crosswith](#crosswith)** method &mdash;
example: `<a b> X~ <y z> == <ay az by bz>;`

<a id="X-test"/>
**:X**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
check if file is executable by real uid ([**\$\*UID**](#UID-global-var))
/ gid ([**\$\*GID**](#GID-global-var))

<a id="x-test"/>
**:x**
*[«io test method»](appendix-b-grouped.html#test-methods)* &mdash;
check if file is executable by effective uid ([**\$\*EUID**](#EUID-global-var))
/ gid ([**\$\*EGID**](#EGID-global-var))

<a id="x-adverb"/>
**:x**
*[«quoting adverb»](appendix-b-grouped.html#quoting-adverbs)* &mdash;
quoted string will be evaluated as Perl code (like
**[eval](#eval)**) and replaced with its result,
alias to **[Q](#Q-op)**
**[:exec](#exec-adverb)** **/.../** and
**[qx/.../](#qx-op)**

<a id="x-modifier"/>
**:x** (<span class="you-provide">n</span>)
*[«regex modifier»](appendix-b-grouped.html#regex-modifier)* &mdash;
searching n times with this pattern

<a id="backslash-X"/>
**\\X\[<span class="you-provide">n</span>\]**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
anything but the character given in hexadecimal (brackets
optional)

<a id="backslash-x"/>
**\\x\[<span class="you-provide">n</span>\]**
*[«escape sequence»](appendix-b-grouped.html#escape-sequences)* &mdash;
character given in hexadecimal (brackets optional)

<a id="xdigit-subrule"/>
**\<xdigit\>**
*[«predefined subrule»](appendix-b-grouped.html#subrules)* &mdash;
single hexadecimal digit char

<a id="xor-op"/>
**xor**
*[«logical op»](tablet-4-operators.html#logical-selection)* &mdash;
*[infix](#infix-category)* logical (*[XOR](appendix-g-glossary.html#xor)*) operator
that operates with into *[bool context](appendix-g-glossary.html#bool-context)*
converted values of both operands without changing their content,
in *bool context* it returns **[True](#True)** or *False* as expected,
in any other context it returns the first none empty value, 
the second when both are empty and [**Nil**](#Nil-type) when both are not empty,
low [precedence](appendix-b-grouped.html#table-of-precedence) version of
[**\^\^**](#caret-caret-op) &mdash;
example: `(5 xor 0)` returns `5` &mdash;
see also: [**or**](#or), [**err**](#err)

<a id="xx"/><a id="xx-op"/>
**xx**
*[«list op»](tablet-4-operators.html#list-generation)* &mdash;
replicate a list <span class="you-provide">l</span> (left operand)
<span class="you-provide">n</span> times (right operand) &mdash;
example: `'ab' xx 3` returns `<ab ab ab>`



# [Y](#nav-top)


# [Z](#nav-top)

<a id="Z-op"/>
**Z**
*[«list op»](tablet-4-operators.html#list-generation)* &mdash;
alias to **[zip](#zip-op)**,
joines *[infix](#infix-category)* 2 lists and stops when one list runs out of elements,
returning always an list with an even length &mdash;
example: `1,2,3,4 Z 8,9 == 1,8,2,9` &mdash; see also: **[roundrobin](#roundrobin)**

<a id="Z-metaop"/>
**Z**<span class="you-provide">op</span>
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
joines *[infix](#infix-category)* the values from same position of 2 lists
with following operator and produces in that manner a new list

<a id="zip"/>
**zip**
*[«array op & method»](tablet-3-variables#array-methods)* &mdash;
*[infix](#infix-category)* zip operator, joines 2 lists, alias to
**[Z operator](#Z-op)** &mdash;
example: `@a Z @b = (@a; @b).zip`

<a id="zipwith"/>
**zipwith**
*[«meta op»](appendix-g-glossary.html#metaoperators)* &mdash;
alias method to **[Z metaoperator](#Z-metaop)** &mdash;
example: `@a Z~ @b` aka `(@a; @b).zipwith(&[~])` aka `(@a; @b).zip.lol.map { .reduce(&[~]) }`

***